Example usage for org.eclipse.jdt.internal.compiler.parser Scanner getCurrentTokenString

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.parser Scanner getCurrentTokenString.

Prototype

public final String getCurrentTokenString() 

Source Link

Usage

From source file:com.codenvy.ide.ext.java.server.core.search.SearchPattern.java

License:Open Source License

private static SearchPattern createFieldPattern(String patternString, int limitTo, int matchRule) {
    // use 1.7 as the source level as there are more valid tokens in 1.7 mode
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
    Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/,
            ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/,
            true/*taskCaseSensitive*/);
    scanner.setSource(patternString.toCharArray());
    final int InsideDeclaringPart = 1;
    final int InsideType = 2;
    int lastToken = -1;

    String declaringType = null, fieldName = null;
    String type = null;/*from   ww w .j  av a 2s.co  m*/
    int mode = InsideDeclaringPart;
    int token;
    try {
        token = scanner.getNextToken();
    } catch (InvalidInputException e) {
        return null;
    }
    while (token != TerminalTokens.TokenNameEOF) {
        switch (mode) {
        // read declaring type and fieldName
        case InsideDeclaringPart:
            switch (token) {
            case TerminalTokens.TokenNameDOT:
                if (declaringType == null) {
                    if (fieldName == null)
                        return null;
                    declaringType = fieldName;
                } else {
                    String tokenSource = scanner.getCurrentTokenString();
                    declaringType += tokenSource + fieldName;
                }
                fieldName = null;
                break;
            case TerminalTokens.TokenNameWHITESPACE:
                if (!(TerminalTokens.TokenNameWHITESPACE == lastToken
                        || TerminalTokens.TokenNameDOT == lastToken))
                    mode = InsideType;
                break;
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                if (fieldName == null)
                    fieldName = scanner.getCurrentTokenString();
                else
                    fieldName += scanner.getCurrentTokenString();
            }
            break;
        // read type
        case InsideType:
            switch (token) {
            case TerminalTokens.TokenNameWHITESPACE:
                break;
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                if (type == null)
                    type = scanner.getCurrentTokenString();
                else
                    type += scanner.getCurrentTokenString();
            }
            break;
        }
        lastToken = token;
        try {
            token = scanner.getNextToken();
        } catch (InvalidInputException e) {
            return null;
        }
    }
    if (fieldName == null)
        return null;

    char[] fieldNameChars = fieldName.toCharArray();
    if (fieldNameChars.length == 1 && fieldNameChars[0] == '*')
        fieldNameChars = null;

    char[] declaringTypeQualification = null, declaringTypeSimpleName = null;
    char[] typeQualification = null, typeSimpleName = null;

    // extract declaring type infos
    if (declaringType != null) {
        char[] declaringTypePart = declaringType.toCharArray();
        int lastDotPosition = CharOperation.lastIndexOf('.', declaringTypePart);
        if (lastDotPosition >= 0) {
            declaringTypeQualification = CharOperation.subarray(declaringTypePart, 0, lastDotPosition);
            if (declaringTypeQualification.length == 1 && declaringTypeQualification[0] == '*')
                declaringTypeQualification = null;
            declaringTypeSimpleName = CharOperation.subarray(declaringTypePart, lastDotPosition + 1,
                    declaringTypePart.length);
        } else {
            declaringTypeSimpleName = declaringTypePart;
        }
        if (declaringTypeSimpleName.length == 1 && declaringTypeSimpleName[0] == '*')
            declaringTypeSimpleName = null;
    }
    // extract type infos
    if (type != null) {
        char[] typePart = type.toCharArray();
        int lastDotPosition = CharOperation.lastIndexOf('.', typePart);
        if (lastDotPosition >= 0) {
            typeQualification = CharOperation.subarray(typePart, 0, lastDotPosition);
            if (typeQualification.length == 1 && typeQualification[0] == '*') {
                typeQualification = null;
            } else {
                // prefix with a '*' as the full qualification could be bigger (because of an import)
                typeQualification = CharOperation.concat(IIndexConstants.ONE_STAR, typeQualification);
            }
            typeSimpleName = CharOperation.subarray(typePart, lastDotPosition + 1, typePart.length);
        } else {
            typeSimpleName = typePart;
        }
        if (typeSimpleName.length == 1 && typeSimpleName[0] == '*')
            typeSimpleName = null;
    }
    // Create field pattern
    return new FieldPattern(fieldNameChars, declaringTypeQualification, declaringTypeSimpleName,
            typeQualification, typeSimpleName, limitTo, matchRule);
}

---

From source file:com.codenvy.ide.ext.java.server.core.search.SearchPattern.java

License:Open Source License

private static SearchPattern createMethodOrConstructorPattern(String patternString, int limitTo, int matchRule,
        boolean isConstructor) {
    // use 1.7 as the source level as there are more valid tokens in 1.7 mode
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
    Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/,
            ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/,
            true/*taskCaseSensitive*/);
    scanner.setSource(patternString.toCharArray());
    final int InsideSelector = 1;
    final int InsideTypeArguments = 2;
    final int InsideParameter = 3;
    final int InsideReturnType = 4;
    int lastToken = -1;

    String declaringType = null, selector = null, parameterType = null;
    String[] parameterTypes = null;
    char[][] typeArguments = null;
    String typeArgumentsString = null;
    int parameterCount = -1;
    String returnType = null;/*  w w  w  .  ja  v a 2  s  .  co m*/
    boolean foundClosingParenthesis = false;
    int mode = InsideSelector;
    int token, argCount = 0;
    try {
        token = scanner.getNextToken();
    } catch (InvalidInputException e) {
        return null;
    }
    while (token != TerminalTokens.TokenNameEOF) {
        switch (mode) {
        // read declaring type and selector
        case InsideSelector:
            if (argCount == 0) {
                switch (token) {
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    if (selector == null || lastToken == TerminalTokens.TokenNameDOT) {
                        typeArgumentsString = scanner.getCurrentTokenString();
                        mode = InsideTypeArguments;
                        break;
                    }
                    if (declaringType == null) {
                        declaringType = selector;
                    } else {
                        declaringType += '.' + selector;
                    }
                    declaringType += scanner.getCurrentTokenString();
                    selector = null;
                    break;
                case TerminalTokens.TokenNameDOT:
                    if (!isConstructor && typeArgumentsString != null)
                        return null; // invalid syntax
                    if (declaringType == null) {
                        if (selector == null)
                            return null; // invalid syntax
                        declaringType = selector;
                    } else if (selector != null) {
                        declaringType += scanner.getCurrentTokenString() + selector;
                    }
                    selector = null;
                    break;
                case TerminalTokens.TokenNameLPAREN:
                    parameterTypes = new String[5];
                    parameterCount = 0;
                    mode = InsideParameter;
                    break;
                case TerminalTokens.TokenNameWHITESPACE:
                    switch (lastToken) {
                    case TerminalTokens.TokenNameWHITESPACE:
                    case TerminalTokens.TokenNameDOT:
                    case TerminalTokens.TokenNameGREATER:
                    case TerminalTokens.TokenNameRIGHT_SHIFT:
                    case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                        break;
                    default:
                        mode = InsideReturnType;
                        break;
                    }
                    break;
                default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                    if (selector == null)
                        selector = scanner.getCurrentTokenString();
                    else
                        selector += scanner.getCurrentTokenString();
                    break;
                }
            } else {
                if (declaringType == null)
                    return null; // invalid syntax
                switch (token) {
                case TerminalTokens.TokenNameGREATER:
                case TerminalTokens.TokenNameRIGHT_SHIFT:
                case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                    argCount--;
                    break;
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    break;
                }
                declaringType += scanner.getCurrentTokenString();
            }
            break;
        // read type arguments
        case InsideTypeArguments:
            if (typeArgumentsString == null)
                return null; // invalid syntax
            typeArgumentsString += scanner.getCurrentTokenString();
            switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                argCount--;
                if (argCount == 0) {
                    String pseudoType = "Type" + typeArgumentsString; //$NON-NLS-1$
                    typeArguments = Signature
                            .getTypeArguments(Signature.createTypeSignature(pseudoType, false).toCharArray());
                    mode = InsideSelector;
                }
                break;
            case TerminalTokens.TokenNameLESS:
                argCount++;
                break;
            }
            break;
        // read parameter types
        case InsideParameter:
            if (argCount == 0) {
                switch (token) {
                case TerminalTokens.TokenNameWHITESPACE:
                    break;
                case TerminalTokens.TokenNameCOMMA:
                    if (parameterType == null)
                        return null;
                    if (parameterTypes != null) {
                        if (parameterTypes.length == parameterCount)
                            System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount * 2],
                                    0, parameterCount);
                        parameterTypes[parameterCount++] = parameterType;
                    }
                    parameterType = null;
                    break;
                case TerminalTokens.TokenNameRPAREN:
                    foundClosingParenthesis = true;
                    if (parameterType != null && parameterTypes != null) {
                        if (parameterTypes.length == parameterCount)
                            System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount * 2],
                                    0, parameterCount);
                        parameterTypes[parameterCount++] = parameterType;
                    }
                    mode = isConstructor ? InsideTypeArguments : InsideReturnType;
                    break;
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    if (parameterType == null)
                        return null; // invalid syntax
                    // $FALL-THROUGH$ - fall through next case to add token
                default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                    if (parameterType == null)
                        parameterType = scanner.getCurrentTokenString();
                    else
                        parameterType += scanner.getCurrentTokenString();
                }
            } else {
                if (parameterType == null)
                    return null; // invalid syntax
                switch (token) {
                case TerminalTokens.TokenNameGREATER:
                case TerminalTokens.TokenNameRIGHT_SHIFT:
                case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                    argCount--;
                    break;
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    break;
                }
                parameterType += scanner.getCurrentTokenString();
            }
            break;
        // read return type
        case InsideReturnType:
            if (argCount == 0) {
                switch (token) {
                case TerminalTokens.TokenNameWHITESPACE:
                    break;
                case TerminalTokens.TokenNameLPAREN:
                    parameterTypes = new String[5];
                    parameterCount = 0;
                    mode = InsideParameter;
                    break;
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    if (returnType == null)
                        return null; // invalid syntax
                    // $FALL-THROUGH$ - fall through next case to add token
                default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                    if (returnType == null)
                        returnType = scanner.getCurrentTokenString();
                    else
                        returnType += scanner.getCurrentTokenString();
                }
            } else {
                if (returnType == null)
                    return null; // invalid syntax
                switch (token) {
                case TerminalTokens.TokenNameGREATER:
                case TerminalTokens.TokenNameRIGHT_SHIFT:
                case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                    argCount--;
                    break;
                case TerminalTokens.TokenNameLESS:
                    argCount++;
                    break;
                }
                returnType += scanner.getCurrentTokenString();
            }
            break;
        }
        lastToken = token;
        try {
            token = scanner.getNextToken();
        } catch (InvalidInputException e) {
            return null;
        }
    }
    // parenthesis mismatch
    if (parameterCount > 0 && !foundClosingParenthesis)
        return null;
    // type arguments mismatch
    if (argCount > 0)
        return null;

    char[] selectorChars = null;
    if (isConstructor) {
        // retrieve type for constructor patterns
        if (declaringType == null)
            declaringType = selector;
        else if (selector != null)
            declaringType += '.' + selector;
    } else {
        // get selector chars
        if (selector == null)
            return null;
        selectorChars = selector.toCharArray();
        if (selectorChars.length == 1 && selectorChars[0] == '*')
            selectorChars = null;
    }

    char[] declaringTypeQualification = null, declaringTypeSimpleName = null;
    char[] returnTypeQualification = null, returnTypeSimpleName = null;
    char[][] parameterTypeQualifications = null, parameterTypeSimpleNames = null;
    // Signatures
    String declaringTypeSignature = null;
    String returnTypeSignature = null;
    String[] parameterTypeSignatures = null;

    // extract declaring type infos
    if (declaringType != null) {
        // get declaring type part and signature
        char[] declaringTypePart = null;
        try {
            declaringTypeSignature = Signature.createTypeSignature(declaringType, false);
            if (declaringTypeSignature.indexOf(Signature.C_GENERIC_START) < 0) {
                declaringTypePart = declaringType.toCharArray();
            } else {
                declaringTypePart = Signature
                        .toCharArray(Signature.getTypeErasure(declaringTypeSignature.toCharArray()));
            }
        } catch (IllegalArgumentException iae) {
            // declaring type is invalid
            return null;
        }
        int lastDotPosition = CharOperation.lastIndexOf('.', declaringTypePart);
        if (lastDotPosition >= 0) {
            declaringTypeQualification = CharOperation.subarray(declaringTypePart, 0, lastDotPosition);
            if (declaringTypeQualification.length == 1 && declaringTypeQualification[0] == '*')
                declaringTypeQualification = null;
            declaringTypeSimpleName = CharOperation.subarray(declaringTypePart, lastDotPosition + 1,
                    declaringTypePart.length);
        } else {
            declaringTypeSimpleName = declaringTypePart;
        }
        if (declaringTypeSimpleName.length == 1 && declaringTypeSimpleName[0] == '*')
            declaringTypeSimpleName = null;
    }
    // extract parameter types infos
    if (parameterCount >= 0) {
        parameterTypeQualifications = new char[parameterCount][];
        parameterTypeSimpleNames = new char[parameterCount][];
        parameterTypeSignatures = new String[parameterCount];
        for (int i = 0; i < parameterCount; i++) {
            // get parameter type part and signature
            char[] parameterTypePart = null;
            try {
                if (parameterTypes != null) {
                    parameterTypeSignatures[i] = Signature.createTypeSignature(parameterTypes[i], false);
                    if (parameterTypeSignatures[i].indexOf(Signature.C_GENERIC_START) < 0) {
                        parameterTypePart = parameterTypes[i].toCharArray();
                    } else {
                        parameterTypePart = Signature.toCharArray(
                                Signature.getTypeErasure(parameterTypeSignatures[i].toCharArray()));
                    }
                }
            } catch (IllegalArgumentException iae) {
                // string is not a valid type syntax
                return null;
            }
            int lastDotPosition = parameterTypePart == null ? -1
                    : CharOperation.lastIndexOf('.', parameterTypePart);
            if (parameterTypePart != null && lastDotPosition >= 0) {
                parameterTypeQualifications[i] = CharOperation.subarray(parameterTypePart, 0, lastDotPosition);
                if (parameterTypeQualifications[i].length == 1 && parameterTypeQualifications[i][0] == '*') {
                    parameterTypeQualifications[i] = null;
                } else {
                    // prefix with a '*' as the full qualification could be bigger (because of an import)
                    parameterTypeQualifications[i] = CharOperation.concat(IIndexConstants.ONE_STAR,
                            parameterTypeQualifications[i]);
                }
                parameterTypeSimpleNames[i] = CharOperation.subarray(parameterTypePart, lastDotPosition + 1,
                        parameterTypePart.length);
            } else {
                parameterTypeQualifications[i] = null;
                parameterTypeSimpleNames[i] = parameterTypePart;
            }
            if (parameterTypeSimpleNames[i].length == 1 && parameterTypeSimpleNames[i][0] == '*')
                parameterTypeSimpleNames[i] = null;
        }
    }
    // extract return type infos
    if (returnType != null) {
        // get return type part and signature
        char[] returnTypePart = null;
        try {
            returnTypeSignature = Signature.createTypeSignature(returnType, false);
            if (returnTypeSignature.indexOf(Signature.C_GENERIC_START) < 0) {
                returnTypePart = returnType.toCharArray();
            } else {
                returnTypePart = Signature
                        .toCharArray(Signature.getTypeErasure(returnTypeSignature.toCharArray()));
            }
        } catch (IllegalArgumentException iae) {
            // declaring type is invalid
            return null;
        }
        int lastDotPosition = CharOperation.lastIndexOf('.', returnTypePart);
        if (lastDotPosition >= 0) {
            returnTypeQualification = CharOperation.subarray(returnTypePart, 0, lastDotPosition);
            if (returnTypeQualification.length == 1 && returnTypeQualification[0] == '*') {
                returnTypeQualification = null;
            } else {
                // because of an import
                returnTypeQualification = CharOperation.concat(IIndexConstants.ONE_STAR,
                        returnTypeQualification);
            }
            returnTypeSimpleName = CharOperation.subarray(returnTypePart, lastDotPosition + 1,
                    returnTypePart.length);
        } else {
            returnTypeSimpleName = returnTypePart;
        }
        if (returnTypeSimpleName.length == 1 && returnTypeSimpleName[0] == '*')
            returnTypeSimpleName = null;
    }
    // Create method/constructor pattern
    if (isConstructor) {
        return new ConstructorPattern(declaringTypeSimpleName, declaringTypeQualification,
                declaringTypeSignature, parameterTypeQualifications, parameterTypeSimpleNames,
                parameterTypeSignatures, typeArguments, limitTo, matchRule);
    } else {
        return new MethodPattern(selectorChars, declaringTypeQualification, declaringTypeSimpleName,
                declaringTypeSignature, returnTypeQualification, returnTypeSimpleName, returnTypeSignature,
                parameterTypeQualifications, parameterTypeSimpleNames, parameterTypeSignatures, typeArguments,
                limitTo, matchRule);
    }
}

---

From source file:com.codenvy.ide.ext.java.server.core.search.SearchPattern.java

License:Open Source License

private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule,
        char indexSuffix) {
    // use 1.7 as the source level as there are more valid tokens in 1.7 mode
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
    Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/,
            ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/,
            true/*taskCaseSensitive*/);
    scanner.setSource(patternString.toCharArray());
    String type = null;//  ww w. java  2 s.  c  om
    int token;
    try {
        token = scanner.getNextToken();
    } catch (InvalidInputException e) {
        return null;
    }
    int argCount = 0;
    while (token != TerminalTokens.TokenNameEOF) {
        if (argCount == 0) {
            switch (token) {
            case TerminalTokens.TokenNameWHITESPACE:
                break;
            case TerminalTokens.TokenNameLESS:
                argCount++;
                // $FALL-THROUGH$ - fall through default case to add token to type
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                if (type == null)
                    type = scanner.getCurrentTokenString();
                else
                    type += scanner.getCurrentTokenString();
            }
        } else {
            switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                argCount--;
                break;
            case TerminalTokens.TokenNameLESS:
                argCount++;
                break;
            }
            if (type == null)
                return null; // invalid syntax
            type += scanner.getCurrentTokenString();
        }
        try {
            token = scanner.getNextToken();
        } catch (InvalidInputException e) {
            return null;
        }
    }
    if (type == null)
        return null;
    String typeSignature = null;
    char[] qualificationChars = null, typeChars = null;

    // get type part and signature
    char[] typePart = null;
    try {
        typeSignature = Signature.createTypeSignature(type, false);
        if (typeSignature.indexOf(Signature.C_GENERIC_START) < 0) {
            typePart = type.toCharArray();
        } else {
            typePart = Signature.toCharArray(Signature.getTypeErasure(typeSignature.toCharArray()));
        }
    } catch (IllegalArgumentException iae) {
        // string is not a valid type syntax
        return null;
    }

    // get qualification name
    int lastDotPosition = CharOperation.lastIndexOf('.', typePart);
    if (lastDotPosition >= 0) {
        qualificationChars = CharOperation.subarray(typePart, 0, lastDotPosition);
        if (qualificationChars.length == 1 && qualificationChars[0] == '*')
            qualificationChars = null;
        typeChars = CharOperation.subarray(typePart, lastDotPosition + 1, typePart.length);
    } else {
        typeChars = typePart;
    }
    if (typeChars.length == 1 && typeChars[0] == '*') {
        typeChars = null;
    }
    switch (limitTo) {
    case IJavaSearchConstants.DECLARATIONS: // cannot search for explicit member types
        return new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule);
    case IJavaSearchConstants.REFERENCES:
        return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, indexSuffix, matchRule);
    case IJavaSearchConstants.IMPLEMENTORS:
        return new SuperTypeReferencePattern(qualificationChars, typeChars,
                SuperTypeReferencePattern.ONLY_SUPER_INTERFACES, indexSuffix, matchRule);
    case IJavaSearchConstants.ALL_OCCURRENCES:
        return new OrPattern(
                new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule), // cannot search for explicit
                // member types
                new TypeReferencePattern(qualificationChars, typeChars, typeSignature, indexSuffix, matchRule));
    default:
        return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, limitTo, indexSuffix,
                matchRule);
    }
}

---

From source file:org.eclipse.che.jdt.core.search.SearchPattern.java

License:Open Source License

private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule,
        char indexSuffix) {
    // use 1.7 as the source level as there are more valid tokens in 1.7 mode
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
    Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/,
            ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/,
            true/*taskCaseSensitive*/);
    scanner.setSource(patternString.toCharArray());
    String type = null;/*www .  j av a  2  s .c o  m*/
    int token;
    try {
        token = scanner.getNextToken();
    } catch (InvalidInputException e) {
        return null;
    }
    int argCount = 0;
    while (token != TerminalTokens.TokenNameEOF) {
        if (argCount == 0) {
            switch (token) {
            case TerminalTokens.TokenNameWHITESPACE:
                break;
            case TerminalTokens.TokenNameLESS:
                argCount++;
                // $FALL-THROUGH$ - fall through default case to add token to type
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
                if (type == null)
                    type = scanner.getCurrentTokenString();
                else
                    type += scanner.getCurrentTokenString();
            }
        } else {
            switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                argCount--;
                break;
            case TerminalTokens.TokenNameLESS:
                argCount++;
                break;
            }
            if (type == null)
                return null; // invalid syntax
            type += scanner.getCurrentTokenString();
        }
        try {
            token = scanner.getNextToken();
        } catch (InvalidInputException e) {
            return null;
        }
    }
    if (type == null)
        return null;
    String typeSignature = null;
    char[] qualificationChars = null, typeChars = null;

    // get type part and signature
    char[] typePart = null;
    try {
        typeSignature = Signature.createTypeSignature(type, false);
        if (typeSignature.indexOf(Signature.C_GENERIC_START) < 0) {
            typePart = type.toCharArray();
        } else {
            typePart = Signature.toCharArray(Signature.getTypeErasure(typeSignature.toCharArray()));
        }
    } catch (IllegalArgumentException iae) {
        // string is not a valid type syntax
        return null;
    }

    // get qualification name
    int lastDotPosition = CharOperation.lastIndexOf('.', typePart);
    if (lastDotPosition >= 0) {
        qualificationChars = CharOperation.subarray(typePart, 0, lastDotPosition);
        if (qualificationChars.length == 1 && qualificationChars[0] == '*')
            qualificationChars = null;
        typeChars = CharOperation.subarray(typePart, lastDotPosition + 1, typePart.length);
    } else {
        typeChars = typePart;
    }
    if (typeChars.length == 1 && typeChars[0] == '*') {
        typeChars = null;
    }
    switch (limitTo) {
    case IJavaSearchConstants.DECLARATIONS: // cannot search for explicit member types
        return new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule);
    case IJavaSearchConstants.REFERENCES:
        return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, indexSuffix, matchRule);
    case IJavaSearchConstants.IMPLEMENTORS:
        return new SuperTypeReferencePattern(qualificationChars, typeChars,
                SuperTypeReferencePattern.ONLY_SUPER_INTERFACES, indexSuffix, matchRule);
    case IJavaSearchConstants.ALL_OCCURRENCES:
        return new OrPattern(
                new QualifiedTypeDeclarationPattern(qualificationChars, typeChars, indexSuffix, matchRule), // cannot search for explicit member types
                new TypeReferencePattern(qualificationChars, typeChars, typeSignature, indexSuffix, matchRule));
    default:
        return new TypeReferencePattern(qualificationChars, typeChars, typeSignature, limitTo, indexSuffix,
                matchRule);
    }
}

---