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

List of usage examples for org.eclipse.jdt.core Signature createTypeSignature

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. Signature
  6. createTypeSignature

Introduction

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

Prototype

public static String createTypeSignature(String typeName, boolean isResolved)

Source Link

Document

Creates a new type signature from the given type name.

Usage

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

License:Open Source License

private String getTypeParameterErasure(ITypeParameter typeParameter, IType context) throws JavaModelException {
    String[] bounds = typeParameter.getBounds();
    if (bounds.length > 0) {
        return getErasedTypeName(Signature.createTypeSignature(bounds[0], false), context);
    }//  ww w .jav  a2 s.com
    return "Object"; //$NON-NLS-1$
}

From source file:at.bestsolution.fxide.jdt.editor.internal.SignatureUtil.java

License:Open Source License

/**
 * Returns the qualified signature corresponding to
 * <code>signature</code>./*from  w  w w  .j ava  2s.c  om*/
 *
 * @param signature the signature to qualify
 * @param context the type inside which an unqualified type will be
 *        resolved to find the qualifier, or <code>null</code> if no
 *        context is available
 * @return the qualified signature
 */
public static String qualifySignature(final String signature, final IType context) {
    if (context == null)
        return signature;

    String qualifier = Signature.getSignatureQualifier(signature);
    if (qualifier.length() > 0)
        return signature;

    String elementType = Signature.getElementType(signature);
    String erasure = Signature.getTypeErasure(elementType);
    String simpleName = Signature.getSignatureSimpleName(erasure);
    String genericSimpleName = Signature.getSignatureSimpleName(elementType);

    int dim = Signature.getArrayCount(signature);

    try {
        String[][] strings = context.resolveType(simpleName);
        if (strings != null && strings.length > 0)
            qualifier = strings[0][0];
    } catch (JavaModelException e) {
        // ignore - not found
    }

    if (qualifier.length() == 0)
        return signature;

    String qualifiedType = Signature.toQualifiedName(new String[] { qualifier, genericSimpleName });
    String qualifiedSignature = Signature.createTypeSignature(qualifiedType, true);
    String newSignature = Signature.createArraySignature(qualifiedSignature, dim);

    return newSignature;
}

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

License:Open Source License

public void appendAnnotationLabel(IAnnotation annotation, long flags) throws JavaModelException {
    fBuffer.append('@');
    appendTypeSignatureLabel(annotation, Signature.createTypeSignature(annotation.getElementName(), false),
            flags);//  w  w w . ja va2 s  . co  m
    IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs();
    if (memberValuePairs.length == 0)
        return;
    fBuffer.append('(');
    for (int i = 0; i < memberValuePairs.length; i++) {
        if (i > 0)
            fBuffer.append(JavaElementLabels.COMMA_STRING);
        IMemberValuePair memberValuePair = memberValuePairs[i];
        fBuffer.append(getMemberName(annotation, annotation.getElementName(), memberValuePair.getMemberName()));
        fBuffer.append('=');
        appendAnnotationValue(annotation, memberValuePair.getValue(), memberValuePair.getValueKind(), flags);
    }
    fBuffer.append(')');
}

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

License:Open Source License

private void appendAnnotationValue(IAnnotation annotation, Object value, int valueKind, long flags)
        throws JavaModelException {
    // Note: To be bug-compatible with Javadoc from Java 5/6/7, we currently don't escape HTML tags in String-valued annotations.
    if (value instanceof Object[]) {
        fBuffer.append('{');
        Object[] values = (Object[]) value;
        for (int j = 0; j < values.length; j++) {
            if (j > 0)
                fBuffer.append(JavaElementLabels.COMMA_STRING);
            value = values[j];//from w ww . j av  a 2 s . c  o m
            appendAnnotationValue(annotation, value, valueKind, flags);
        }
        fBuffer.append('}');
    } else {
        switch (valueKind) {
        case IMemberValuePair.K_CLASS:
            appendTypeSignatureLabel(annotation, Signature.createTypeSignature((String) value, false), flags);
            fBuffer.append(".class"); //$NON-NLS-1$
            break;
        case IMemberValuePair.K_QUALIFIED_NAME:
            String name = (String) value;
            int lastDot = name.lastIndexOf('.');
            if (lastDot != -1) {
                String type = name.substring(0, lastDot);
                String field = name.substring(lastDot + 1);
                appendTypeSignatureLabel(annotation, Signature.createTypeSignature(type, false), flags);
                fBuffer.append('.');
                fBuffer.append(getMemberName(annotation, type, field));
                break;
            }
            //            case IMemberValuePair.K_SIMPLE_NAME: // can't implement, since parent type is not known
            //$FALL-THROUGH$
        case IMemberValuePair.K_ANNOTATION:
            appendAnnotationLabel((IAnnotation) value, flags);
            break;
        case IMemberValuePair.K_STRING:
            fBuffer.append(ASTNodes.getEscapedStringLiteral((String) value));
            break;
        case IMemberValuePair.K_CHAR:
            fBuffer.append(ASTNodes.getEscapedCharacterLiteral(((Character) value).charValue()));
            break;
        default:
            fBuffer.append(String.valueOf(value));
            break;
        }
    }
}

From source file:ca.ecliptical.pde.ds.search.DescriptorQueryParticipant.java

License:Open Source License

private IMethod findBindMethod(IType implClassType, String name, String referenceTypeName,
        IProgressMonitor monitor) throws JavaModelException {
    IMethod candidate = null;/*from w w  w.  j a  v  a2 s  .co  m*/
    int priority = Integer.MAX_VALUE;

    String referenceTypeSig = Signature.createTypeSignature(referenceTypeName, true);
    IType referenceType = null;
    IType arg0Type = null;

    IType type = implClassType;
    while (type != null) {
        for (IMethod method : type.getMethods()) {
            if (!name.equals(method.getElementName()))
                continue;

            if (!VOID_SIG.equals(method.getReturnType()))
                continue;

            if (type != implClassType && (Flags.isPrivate(method.getFlags())
                    || (Flags.isPackageDefault(method.getFlags()) && !implClassType.getPackageFragment()
                            .equals(method.getDeclaringType().getPackageFragment()))))
                continue;

            String[] paramSigs = resolveParameterTypes(method, 2);

            if (paramSigs.length == 1 && SERVICE_REFERENCE_SIG.equals(paramSigs[0])) {
                // best match
                return method;
            }

            if (priority > 1 && paramSigs.length == 1 && referenceTypeSig.equals(paramSigs[0])) {
                candidate = method;
                priority = 1;
                continue;
            }

            if (priority > 2 && paramSigs.length == 1) {
                if (referenceType == null)
                    referenceType = implClassType.getJavaProject().findType(referenceTypeName, monitor);

                if (arg0Type == null)
                    arg0Type = implClassType.getJavaProject().findType(Signature.toString(paramSigs[0]),
                            monitor);

                if (isAssignableFrom(arg0Type, referenceType, monitor)) {
                    candidate = method;
                    priority = 2;
                }

                continue;
            }

            if (priority > 3 && paramSigs.length == 2 && referenceTypeSig.equals(paramSigs[0])
                    && MAP_SIG.equals(paramSigs[1])) {
                candidate = method;
                priority = 3;
                continue;
            }

            if (priority > 4 && paramSigs.length == 2 && MAP_SIG.equals(paramSigs[1])) {
                if (referenceType == null)
                    referenceType = implClassType.getJavaProject().findType(referenceTypeName, monitor);

                if (arg0Type == null)
                    arg0Type = implClassType.getJavaProject().findType(Signature.toString(paramSigs[0]),
                            monitor);

                if (isAssignableFrom(arg0Type, referenceType, monitor)) {
                    candidate = method;
                    priority = 4;
                }

                continue;
            }
        }

        type = findSuperclassType(type, implClassType.getJavaProject(), monitor);
    }

    return candidate;
}

From source file:ca.ecliptical.pde.ds.search.DescriptorQueryParticipant.java

License:Open Source License

private String[] resolveParameterTypes(IMethod method, int maxParams) throws JavaModelException {
    String[] oldParamSigs = method.getParameterTypes();
    String[] paramSigs = new String[oldParamSigs.length];
    System.arraycopy(oldParamSigs, 0, paramSigs, 0, paramSigs.length);
    for (int i = 0, n = Math.min(paramSigs.length, maxParams); i < n; ++i) {
        paramSigs[i] = Signature.getTypeErasure(paramSigs[i]);
        if (!method.isResolved()) {
            String[][] resolvedParamTypes = method.getDeclaringType()
                    .resolveType(Signature.toString(paramSigs[i]));
            if (resolvedParamTypes != null && resolvedParamTypes.length > 0) {
                // TODO should we use all results??
                paramSigs[i] = Signature.createTypeSignature(
                        resolvedParamTypes[0][0].length() == 0 ? resolvedParamTypes[0][1]
                                : String.format("%s.%s", resolvedParamTypes[0][0], resolvedParamTypes[0][1]), //$NON-NLS-1$
                        true);//  ww w .ja  v  a2  s .c  o m
            }
        }
    }

    return paramSigs;
}

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;//from w ww.  j  a va2  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;/*w  w w  .  j a va 2 s .co 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);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.codeassist.SelectionEngine.java

License:Open Source License

private boolean checkTypeArgument(Scanner scanner) {
    int depth = 1;
    int token;/* w  ww .  j av a2 s . c om*/
    StringBuffer buffer = new StringBuffer();
    do {
        try {
            token = scanner.getNextToken();
        } catch (InvalidInputException e) {
            return false;
        }
        switch (token) {
        case TerminalTokens.TokenNameLESS:
            depth++;
            buffer.append(scanner.getCurrentTokenSource());
            break;
        case TerminalTokens.TokenNameGREATER:
            depth--;
            buffer.append(scanner.getCurrentTokenSource());
            break;
        case TerminalTokens.TokenNameRIGHT_SHIFT:
            depth -= 2;
            buffer.append(scanner.getCurrentTokenSource());
            break;
        case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
            depth -= 3;
            buffer.append(scanner.getCurrentTokenSource());
            break;
        case TerminalTokens.TokenNameextends:
        case TerminalTokens.TokenNamesuper:
            buffer.append(' ');
            buffer.append(scanner.getCurrentTokenSource());
            buffer.append(' ');
            break;
        case TerminalTokens.TokenNameCOMMA:
            if (depth == 1) {
                int length = buffer.length();
                char[] typeRef = new char[length];
                buffer.getChars(0, length, typeRef, 0);
                try {
                    Signature.createTypeSignature(typeRef, true);
                    buffer = new StringBuffer();
                } catch (IllegalArgumentException e) {
                    return false;
                }
            }
            break;
        default:
            buffer.append(scanner.getCurrentTokenSource());
            break;

        }
        if (depth < 0) {
            return false;
        }
    } while (depth != 0 && token != TerminalTokens.TokenNameEOF);

    if (depth == 0) {
        int length = buffer.length() - 1;
        char[] typeRef = new char[length];
        buffer.getChars(0, length, typeRef, 0);
        try {
            Signature.createTypeSignature(typeRef, true);
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    return false;
}

From source file:com.codenvy.ide.ext.java.server.internal.codeassist.SelectionEngine.java

License:Open Source License

private Object findMethodWithAttachedDocInHierarchy(final MethodBinding method) throws JavaModelException {
    ReferenceBinding type = method.declaringClass;
    final SelectionRequestor requestor1 = (SelectionRequestor) this.requestor;
    return new InheritDocVisitor() {
        public Object visit(ReferenceBinding currType) throws JavaModelException {
            MethodBinding overridden = findOverriddenMethodInType(currType, method);
            if (overridden == null)
                return InheritDocVisitor.CONTINUE;
            TypeBinding args[] = overridden.parameters;
            String names[] = new String[args.length];
            for (int i = 0; i < args.length; i++) {
                names[i] = Signature.createTypeSignature(args[i].sourceName(), false);
            }//from   www. j  ava 2  s. com
            IMember member = (IMember) requestor1.findMethodFromBinding(overridden, names,
                    overridden.declaringClass);
            if (member == null)
                return InheritDocVisitor.CONTINUE;
            if (member.getAttachedJavadoc(null) != null) {
                // for binary methods with attached javadoc and no source attached
                return overridden;
            }
            IOpenable openable = member.getOpenable();
            if (openable == null)
                return InheritDocVisitor.CONTINUE;
            IBuffer buf = openable.getBuffer();
            if (buf == null) {
                // no source attachment found. This method maybe the one. Stop.
                return InheritDocVisitor.STOP_BRANCH;
            }

            ISourceRange javadocRange = member.getJavadocRange();
            if (javadocRange == null)
                return InheritDocVisitor.CONTINUE; // this method doesn't have javadoc, continue to look.
            String rawJavadoc = buf.getText(javadocRange.getOffset(), javadocRange.getLength());
            if (rawJavadoc != null) {
                return overridden;
            }
            return InheritDocVisitor.CONTINUE;
        }
    }.visitInheritDoc(type);
}