Example usage for org.eclipse.jdt.core.compiler CharOperation replace

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.compiler CharOperation replace.

Prototype

public static final char[] replace(char[] array, char[] toBeReplaced, char[] replacementChars) 

Source Link

Document

Answers a new array of characters with substitutions.

Usage

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

License:Open Source License

/**
 * Returns a search pattern based on a given Java element.
 * The pattern is used to trigger the appropriate search, and can be parameterized as follows:
 *
 * @param element the Java element the search pattern is based on
 * @param limitTo determines the nature of the expected matches
 *   <ul>// w  w w .  ja v  a  2  s  .co  m
 *    <li>{@link IJavaSearchConstants#DECLARATIONS DECLARATIONS}: will search declarations matching
 *          with the corresponding element. In case the element is a method, declarations of matching
 *          methods in sub-types will also be found, allowing to find declarations of abstract methods, etc.
 *            Some additional flags may be specified while searching declaration:
 *            <ul>
 *               <li>{@link IJavaSearchConstants#IGNORE_DECLARING_TYPE IGNORE_DECLARING_TYPE}: declaring type will be ignored
 *                     during the search.<br>
 *                     For example using following test case:
 *               <pre>
 *                  class A { A method() { return null; } }
 *                  class B extends A { B method() { return null; } }
 *                  class C { A method() { return null; } }
 *               </pre>
 *                     search for <code>method</code> declaration with this flag
 *                     will return 2 matches: in A and in C
 *               </li>
 *               <li>{@link IJavaSearchConstants#IGNORE_RETURN_TYPE IGNORE_RETURN_TYPE}: return type will be ignored
 *                     during the search.<br>
 *                     Using same example, search for <code>method</code> declaration with this flag
 *                     will return 2 matches: in A and in B.
 *               </li>
 *            </ul>
 *            Note that these two flags may be combined and both declaring and return types can be ignored
 *            during the search. Then, using same example, search for <code>method</code> declaration
 *            with these 2 flags will return 3 matches: in A, in B  and in C
 *    </li>
 *       <li>{@link IJavaSearchConstants#REFERENCES REFERENCES}: will search references to the given element.</li>
 *       <li>{@link IJavaSearchConstants#ALL_OCCURRENCES ALL_OCCURRENCES}: will search for either declarations or
 *            references as specified above.
 *      </li>
 *       <li>All other fine grain constants defined in the <b>limitTo</b> category
 *            of the {@link IJavaSearchConstants} are also accepted nature:
 *          <table border=0>
 *              <tr>
 *               <th align=left>Fine grain constant
 *               <th align=left>Meaning
 *              <tr>
 *               <td>{@link IJavaSearchConstants#FIELD_DECLARATION_TYPE_REFERENCE FIELD_DECLARATION_TYPE_REFERENCE}
 *               <td>Return only type references used as the type of a field declaration.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#LOCAL_VARIABLE_DECLARATION_TYPE_REFERENCE LOCAL_VARIABLE_DECLARATION_TYPE_REFERENCE}
 *               <td>Return only type references used as the type of a local variable declaration.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#PARAMETER_DECLARATION_TYPE_REFERENCE PARAMETER_DECLARATION_TYPE_REFERENCE}
 *               <td>Return only type references used as the type of a method parameter declaration.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#SUPERTYPE_TYPE_REFERENCE SUPERTYPE_TYPE_REFERENCE}
 *               <td>Return only type references used as a super type or as a super interface.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#THROWS_CLAUSE_TYPE_REFERENCE THROWS_CLAUSE_TYPE_REFERENCE}
 *               <td>Return only type references used in a throws clause.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#CAST_TYPE_REFERENCE CAST_TYPE_REFERENCE}
 *               <td>Return only type references used in a cast expression.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#CATCH_TYPE_REFERENCE CATCH_TYPE_REFERENCE}
 *               <td>Return only type references used in a catch header.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#CLASS_INSTANCE_CREATION_TYPE_REFERENCE CLASS_INSTANCE_CREATION_TYPE_REFERENCE}
 *               <td>Return only type references used in class instance creation.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#RETURN_TYPE_REFERENCE RETURN_TYPE_REFERENCE}
 *               <td>Return only type references used as a method return type.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#IMPORT_DECLARATION_TYPE_REFERENCE IMPORT_DECLARATION_TYPE_REFERENCE}
 *               <td>Return only type references used in an import declaration.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#ANNOTATION_TYPE_REFERENCE ANNOTATION_TYPE_REFERENCE}
 *               <td>Return only type references used as an annotation.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#TYPE_ARGUMENT_TYPE_REFERENCE TYPE_ARGUMENT_TYPE_REFERENCE}
 *               <td>Return only type references used as a type argument in a parameterized type or a parameterized method.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#TYPE_VARIABLE_BOUND_TYPE_REFERENCE TYPE_VARIABLE_BOUND_TYPE_REFERENCE}
 *               <td>Return only type references used as a type variable bound.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#WILDCARD_BOUND_TYPE_REFERENCE WILDCARD_BOUND_TYPE_REFERENCE}
 *               <td>Return only type references used as a wildcard bound.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#INSTANCEOF_TYPE_REFERENCE INSTANCEOF_TYPE_REFERENCE}
 *               <td>Return only type references used as a type of an <code>instanceof</code> expression.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#SUPER_REFERENCE SUPER_REFERENCE}
 *               <td>Return only super field accesses or super method invocations (e.g. using the <code>super</code> qualifier).
 *              <tr>
 *               <td>{@link IJavaSearchConstants#QUALIFIED_REFERENCE QUALIFIED_REFERENCE}
 *               <td>Return only qualified field accesses or qualified method invocations.
 *              <tr>
 *               <td>{@link IJavaSearchConstants#THIS_REFERENCE THIS_REFERENCE}
 *               <td>Return only primary field accesses or primary method invocations (e.g. using the <code>this</code> qualifier).
 *              <tr>
 *               <td>{@link IJavaSearchConstants#IMPLICIT_THIS_REFERENCE IMPLICIT_THIS_REFERENCE}
 *               <td>Return only field accesses or method invocations without any qualification.
 *          </table>
 *    </li>
 *   </ul>
 * @param matchRule one of the following match rules:
 *    <ul>
 *       <li>{@link #R_EXACT_MATCH}</li>
 *       <li>{@link #R_PREFIX_MATCH}</li>
 *       <li>{@link #R_PATTERN_MATCH}</li>
 *       <li>{@link #R_CAMELCASE_MATCH}</li>
 *       <li>{@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}</li>
 *    </ul>
 *    , which may be also combined with one of the following flags:
 *    <ul>
 *       <li>{@link #R_CASE_SENSITIVE}</li>
 *       <li>{@link #R_ERASURE_MATCH}</li>
 *       <li>{@link #R_EQUIVALENT_MATCH}</li>
 *    </ul>
 *      For example,
 *      <ul>
 *         <li>{@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE}: if an exact
 *            and case sensitive match is requested,</li>
 *         <li>{@link #R_PREFIX_MATCH} if a case insensitive prefix match is requested</li>
 *         <li>{@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}: if a case
 *            insensitive and erasure match is requested.</li>
 *      </ul>
 *    Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} has no effect
 *    on non-generic types/methods search.
 *    <p>
 *    Note also that default behavior for generic types/methods search is to find exact matches.
 * @return a search pattern for a Java element or <code>null</code> if the given element is ill-formed
 * @since 3.1
 */
public static SearchPattern createPattern(IJavaElement element, int limitTo, int matchRule) {
    SearchPattern searchPattern = null;
    int lastDot;
    boolean ignoreDeclaringType = false;
    boolean ignoreReturnType = false;
    int maskedLimitTo = limitTo
            & ~(IJavaSearchConstants.IGNORE_DECLARING_TYPE + IJavaSearchConstants.IGNORE_RETURN_TYPE);
    if (maskedLimitTo == IJavaSearchConstants.DECLARATIONS
            || maskedLimitTo == IJavaSearchConstants.ALL_OCCURRENCES) {
        ignoreDeclaringType = (limitTo & IJavaSearchConstants.IGNORE_DECLARING_TYPE) != 0;
        ignoreReturnType = (limitTo & IJavaSearchConstants.IGNORE_RETURN_TYPE) != 0;
    }
    if ((matchRule = validateMatchRule(null, matchRule)) == -1) {
        return null;
    }
    char[] declaringSimpleName = null;
    char[] declaringQualification = null;
    switch (element.getElementType()) {
    case IJavaElement.FIELD:
        IField field = (IField) element;
        if (!ignoreDeclaringType) {
            IType declaringClass = field.getDeclaringType();
            declaringSimpleName = declaringClass.getElementName().toCharArray();
            declaringQualification = declaringClass.getPackageFragment().getElementName().toCharArray();
            char[][] enclosingNames = enclosingTypeNames(declaringClass);
            if (enclosingNames.length > 0) {
                declaringQualification = CharOperation.concat(declaringQualification,
                        CharOperation.concatWith(enclosingNames, '.'), '.');
            }
        }
        char[] name = field.getElementName().toCharArray();
        char[] typeSimpleName = null;
        char[] typeQualification = null;
        String typeSignature = null;
        if (!ignoreReturnType) {
            try {
                typeSignature = field.getTypeSignature();
                char[] signature = typeSignature.toCharArray();
                char[] typeErasure = Signature.toCharArray(Signature.getTypeErasure(signature));
                CharOperation.replace(typeErasure, '$', '.');
                if ((lastDot = CharOperation.lastIndexOf('.', typeErasure)) == -1) {
                    typeSimpleName = typeErasure;
                } else {
                    typeSimpleName = CharOperation.subarray(typeErasure, lastDot + 1, typeErasure.length);
                    typeQualification = CharOperation.subarray(typeErasure, 0, lastDot);
                    if (!field.isBinary()) {
                        // prefix with a '*' as the full qualification could be bigger (because of an import)
                        typeQualification = CharOperation.concat(IIndexConstants.ONE_STAR, typeQualification);
                    }
                }
            } catch (JavaModelException e) {
                return null;
            }
        }
        // Create field pattern
        searchPattern = new FieldPattern(name, declaringQualification, declaringSimpleName, typeQualification,
                typeSimpleName, typeSignature, limitTo, matchRule);
        break;
    case IJavaElement.IMPORT_DECLARATION:
        String elementName = element.getElementName();
        lastDot = elementName.lastIndexOf('.');
        if (lastDot == -1)
            return null; // invalid import declaration
        IImportDeclaration importDecl = (IImportDeclaration) element;
        if (importDecl.isOnDemand()) {
            searchPattern = createPackagePattern(elementName.substring(0, lastDot), maskedLimitTo, matchRule);
        } else {
            searchPattern = createTypePattern(elementName.substring(lastDot + 1).toCharArray(),
                    elementName.substring(0, lastDot).toCharArray(), null, null, null, maskedLimitTo,
                    matchRule);
        }
        break;
    case IJavaElement.LOCAL_VARIABLE:
        LocalVariable localVar = (LocalVariable) element;
        searchPattern = new LocalVariablePattern(localVar, limitTo, matchRule);
        break;
    case IJavaElement.TYPE_PARAMETER:
        ITypeParameter typeParam = (ITypeParameter) element;
        boolean findParamDeclarations = true;
        boolean findParamReferences = true;
        switch (maskedLimitTo) {
        case IJavaSearchConstants.DECLARATIONS:
            findParamReferences = false;
            break;
        case IJavaSearchConstants.REFERENCES:
            findParamDeclarations = false;
            break;
        }
        searchPattern = new TypeParameterPattern(findParamDeclarations, findParamReferences, typeParam,
                matchRule);
        break;
    case IJavaElement.METHOD:
        IMethod method = (IMethod) element;
        boolean isConstructor;
        try {
            isConstructor = method.isConstructor();
        } catch (JavaModelException e) {
            return null;
        }
        IType declaringClass = method.getDeclaringType();
        if (ignoreDeclaringType) {
            if (isConstructor)
                declaringSimpleName = declaringClass.getElementName().toCharArray();
        } else {
            declaringSimpleName = declaringClass.getElementName().toCharArray();
            declaringQualification = declaringClass.getPackageFragment().getElementName().toCharArray();
            char[][] enclosingNames = enclosingTypeNames(declaringClass);
            if (enclosingNames.length > 0) {
                declaringQualification = CharOperation.concat(declaringQualification,
                        CharOperation.concatWith(enclosingNames, '.'), '.');
            }
        }
        char[] selector = method.getElementName().toCharArray();
        char[] returnSimpleName = null;
        char[] returnQualification = null;
        String returnSignature = null;
        if (!ignoreReturnType) {
            try {
                returnSignature = method.getReturnType();
                char[] signature = returnSignature.toCharArray();
                char[] returnErasure = Signature.toCharArray(Signature.getTypeErasure(signature));
                CharOperation.replace(returnErasure, '$', '.');
                if ((lastDot = CharOperation.lastIndexOf('.', returnErasure)) == -1) {
                    returnSimpleName = returnErasure;
                } else {
                    returnSimpleName = CharOperation.subarray(returnErasure, lastDot + 1, returnErasure.length);
                    returnQualification = CharOperation.subarray(returnErasure, 0, lastDot);
                    if (!method.isBinary()) {
                        // prefix with a '*' as the full qualification could be bigger (because of an import)
                        CharOperation.concat(IIndexConstants.ONE_STAR, returnQualification);
                    }
                }
            } catch (JavaModelException e) {
                return null;
            }
        }
        String[] parameterTypes = method.getParameterTypes();
        int paramCount = parameterTypes.length;
        char[][] parameterSimpleNames = new char[paramCount][];
        char[][] parameterQualifications = new char[paramCount][];
        String[] parameterSignatures = new String[paramCount];
        for (int i = 0; i < paramCount; i++) {
            parameterSignatures[i] = parameterTypes[i];
            char[] signature = parameterSignatures[i].toCharArray();
            char[] paramErasure = Signature.toCharArray(Signature.getTypeErasure(signature));
            CharOperation.replace(paramErasure, '$', '.');
            if ((lastDot = CharOperation.lastIndexOf('.', paramErasure)) == -1) {
                parameterSimpleNames[i] = paramErasure;
                parameterQualifications[i] = null;
            } else {
                parameterSimpleNames[i] = CharOperation.subarray(paramErasure, lastDot + 1,
                        paramErasure.length);
                parameterQualifications[i] = CharOperation.subarray(paramErasure, 0, lastDot);
                if (!method.isBinary()) {
                    // prefix with a '*' as the full qualification could be bigger (because of an import)
                    CharOperation.concat(IIndexConstants.ONE_STAR, parameterQualifications[i]);
                }
            }
        }

        // Create method/constructor pattern
        if (isConstructor) {
            searchPattern = new ConstructorPattern(declaringSimpleName, declaringQualification,
                    parameterQualifications, parameterSimpleNames, parameterSignatures, method, limitTo,
                    matchRule);
        } else {
            searchPattern = new MethodPattern(selector, declaringQualification, declaringSimpleName,
                    returnQualification, returnSimpleName, returnSignature, parameterQualifications,
                    parameterSimpleNames, parameterSignatures, method, limitTo, matchRule);
        }
        break;
    case IJavaElement.TYPE:
        IType type = (IType) element;
        searchPattern = createTypePattern(type.getElementName().toCharArray(),
                type.getPackageFragment().getElementName().toCharArray(),
                ignoreDeclaringType ? null : enclosingTypeNames(type), null, type, maskedLimitTo, matchRule);
        break;
    case IJavaElement.PACKAGE_DECLARATION:
    case IJavaElement.PACKAGE_FRAGMENT:
        searchPattern = createPackagePattern(element.getElementName(), maskedLimitTo, matchRule);
        break;
    }
    if (searchPattern != null)
        MatchLocator.setFocus(searchPattern, element);
    return searchPattern;
}

---

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

License:Open Source License

public String[] getParameterNames() throws JavaModelException {
    if (this.parameterNames != null)
        return this.parameterNames;

    // force source mapping if not already done
    IType type = (IType) getParent();//from www . jav  a  2s  .  c  om
    SourceMapper mapper = getSourceMapper();
    if (mapper != null) {
        char[][] paramNames = mapper.getMethodParameterNames(this);

        // map source and try to find parameter names
        if (paramNames == null) {
            IBinaryType info = (IBinaryType) ((BinaryType) getDeclaringType()).getElementInfo();
            char[] source = mapper.findSource(type, info);
            if (source != null) {
                mapper.mapSource(type, source, info);
            }
            paramNames = mapper.getMethodParameterNames(this);
        }

        // if parameter names exist, convert parameter names to String array
        if (paramNames != null) {
            String[] names = new String[paramNames.length];
            for (int i = 0; i < paramNames.length; i++) {
                names[i] = new String(paramNames[i]);
            }
            return this.parameterNames = names;
        }
    }

    // try to see if we can retrieve the names from the attached javadoc
    IBinaryMethod info = (IBinaryMethod) getElementInfo();
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=316937
    // Use Signature#getParameterCount() only if the argument names are not already available.
    int paramCount = Signature.getParameterCount(new String(info.getMethodDescriptor()));
    if (this.isConstructor()) {
        final IType declaringType = this.getDeclaringType();
        if (declaringType.isMember() && !Flags.isStatic(declaringType.getFlags())) {
            paramCount--; // remove synthetic argument from constructor param count
        } else if (declaringType.isEnum()) {
            if (paramCount >= 2) // https://bugs.eclipse.org/bugs/show_bug.cgi?id=436347
                paramCount -= 2;
        }
    }

    if (paramCount != 0) {
        // don't try to look for javadoc for synthetic methods
        int modifiers = getFlags();
        if ((modifiers & ClassFileConstants.AccSynthetic) != 0) {
            return this.parameterNames = getRawParameterNames(paramCount);
        }
        JavadocContents javadocContents = null;
        IType declaringType = getDeclaringType();
        JavaModelManager.PerProjectInfo projectInfo = manager.getPerProjectInfoCheckExistence();
        synchronized (projectInfo.javadocCache) {
            javadocContents = (JavadocContents) projectInfo.javadocCache.get(declaringType);
            if (javadocContents == null) {
                projectInfo.javadocCache.put(declaringType, BinaryType.EMPTY_JAVADOC);
            }
        }

        String methodDoc = null;
        if (javadocContents == null) {
            long timeOut = 50; // default value
            try {
                String option = getJavaProject()
                        .getOption(JavaCore.TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC, true);
                if (option != null) {
                    timeOut = Long.parseLong(option);
                }
            } catch (NumberFormatException e) {
                // ignore
            }
            if (timeOut == 0) {
                // don't try to fetch the values and don't cache either (https://bugs.eclipse.org/bugs/show_bug.cgi?id=329671)
                return getRawParameterNames(paramCount);
            }
            final class ParametersNameCollector {
                String javadoc;

                public void setJavadoc(String s) {
                    this.javadoc = s;
                }

                public String getJavadoc() {
                    return this.javadoc;
                }
            }
            /*
             * The declaring type is not in the cache yet. The thread wil retrieve the javadoc contents
             */
            final ParametersNameCollector nameCollector = new ParametersNameCollector();
            Thread collect = new Thread() {
                public void run() {
                    try {
                        // this call has a side-effect on the per project info cache
                        nameCollector.setJavadoc(BinaryMethod.this.getAttachedJavadoc(null));
                    } catch (JavaModelException e) {
                        // ignore
                    }
                    synchronized (nameCollector) {
                        nameCollector.notify();
                    }
                }
            };
            collect.start();
            synchronized (nameCollector) {
                try {
                    nameCollector.wait(timeOut);
                } catch (InterruptedException e) {
                    // ignore
                }
            }
            methodDoc = nameCollector.getJavadoc();
        } else if (javadocContents != BinaryType.EMPTY_JAVADOC) {
            // need to extract the part relative to the binary method since javadoc contains the javadoc for the declaring type
            try {
                methodDoc = javadocContents.getMethodDoc(this);
            } catch (JavaModelException e) {
                javadocContents = null;
            }
        }
        if (methodDoc != null) {
            int indexOfOpenParen = methodDoc.indexOf('(');
            // Annotations may have parameters, so make sure we are parsing the actual method parameters.
            if (info.getAnnotations() != null) {
                while (indexOfOpenParen != -1
                        && !isOpenParenForMethod(methodDoc, getElementName(), indexOfOpenParen)) {
                    indexOfOpenParen = methodDoc.indexOf('(', indexOfOpenParen + 1);
                }
            }
            if (indexOfOpenParen != -1) {
                final int indexOfClosingParen = methodDoc.indexOf(')', indexOfOpenParen);
                if (indexOfClosingParen != -1) {
                    final char[] paramsSource = CharOperation.replace(
                            methodDoc.substring(indexOfOpenParen + 1, indexOfClosingParen).toCharArray(),
                            "&nbsp;".toCharArray(), //$NON-NLS-1$
                            new char[] { ' ' });
                    final char[][] params = splitParameters(paramsSource, paramCount);
                    final int paramsLength = params.length;
                    String[] names = new String[paramsLength];
                    for (int i = 0; i < paramsLength; i++) {
                        final char[] param = params[i];
                        int indexOfSpace = CharOperation.lastIndexOf(' ', param);
                        if (indexOfSpace != -1) {
                            names[i] = String.valueOf(param, indexOfSpace + 1, param.length - indexOfSpace - 1);
                        } else {
                            names[i] = "arg" + i; //$NON-NLS-1$
                        }
                    }
                    return this.parameterNames = names;
                }
            }
        }
        // let's see if we can retrieve them from the debug infos
        char[][] argumentNames = info.getArgumentNames();
        if (argumentNames != null && argumentNames.length == paramCount) {
            String[] names = new String[paramCount];
            for (int i = 0; i < paramCount; i++) {
                names[i] = new String(argumentNames[i]);
            }
            return this.parameterNames = names;
        }
    }
    // If still no parameter names, produce fake ones, but don't cache them (https://bugs.eclipse.org/bugs/show_bug.cgi?id=329671)
    return getRawParameterNames(paramCount);
    //   throw new UnsupportedOperationException();
}

---

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

License:Open Source License

/**
 * Creates the handles and infos for the type parameter of the given binary member.
 * Adds new handles to the given vector.
 *///from  w ww  .java2 s .c o m
private void generateTypeParameterInfos(BinaryMember parent, char[] signature, HashMap newElements,
        ArrayList typeParameterHandles) {
    if (signature == null)
        return;
    char[][] typeParameterSignatures = Signature.getTypeParameters(signature);
    for (int i = 0, typeParameterCount = typeParameterSignatures.length; i < typeParameterCount; i++) {
        char[] typeParameterSignature = typeParameterSignatures[i];
        char[] typeParameterName = Signature.getTypeVariable(typeParameterSignature);
        CharOperation.replace(typeParameterSignature, '/', '.');
        char[][] typeParameterBoundSignatures = Signature.getTypeParameterBounds(typeParameterSignature);
        int boundLength = typeParameterBoundSignatures.length;
        char[][] typeParameterBounds = new char[boundLength][];
        for (int j = 0; j < boundLength; j++) {
            typeParameterBounds[j] = Signature.toCharArray(typeParameterBoundSignatures[j]);
        }
        TypeParameter typeParameter = new TypeParameter(parent, parent.manager, new String(typeParameterName));
        TypeParameterElementInfo info = new TypeParameterElementInfo();
        info.bounds = typeParameterBounds;
        info.boundsSignatures = typeParameterBoundSignatures;
        typeParameterHandles.add(typeParameter);

        // ensure that 2 binary methods with the same signature but with different return types have different occurence counts.
        // (case of bridge methods in 1.5)
        while (newElements.containsKey(typeParameter))
            typeParameter.occurrenceCount++;

        newElements.put(typeParameter, info);
    }
    //   throw new UnsupportedOperationException();
}

---

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

License:Open Source License

protected String getKey(IMethod method, boolean forceOpen) throws JavaModelException {
    StringBuffer key = new StringBuffer();

    // declaring class
    String declaringKey = getKey((IType) method.getParent(), forceOpen);
    key.append(declaringKey);/*from  w  ww.  j a  va 2 s  .c  o m*/

    // selector
    key.append('.');
    String selector = method.getElementName();
    key.append(selector);

    // type parameters
    if (forceOpen) {
        ITypeParameter[] typeParameters = method.getTypeParameters();
        int length = typeParameters.length;
        if (length > 0) {
            key.append('<');
            for (int i = 0; i < length; i++) {
                ITypeParameter typeParameter = typeParameters[i];
                String[] bounds = typeParameter.getBounds();
                int boundsLength = bounds.length;
                char[][] boundSignatures = new char[boundsLength][];
                for (int j = 0; j < boundsLength; j++) {
                    boundSignatures[j] = Signature.createCharArrayTypeSignature(bounds[j].toCharArray(),
                            method.isBinary());
                    CharOperation.replace(boundSignatures[j], '.', '/');
                }
                char[] sig = Signature.createTypeParameterSignature(
                        typeParameter.getElementName().toCharArray(), boundSignatures);
                key.append(sig);
            }
            key.append('>');
        }
    }

    // parameters
    key.append('(');
    String[] parameters = method.getParameterTypes();
    for (int i = 0, length = parameters.length; i < length; i++)
        key.append(parameters[i].replace('.', '/'));
    key.append(')');

    // return type
    if (forceOpen)
        key.append(method.getReturnType().replace('.', '/'));
    else
        key.append('V');

    return key.toString();
}

---

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

License:Open Source License

public void searchAllConstructorDeclarations(final char[] packageName, final char[] typeName,
        final int typeMatchRule, IJavaSearchScope scope,
        final IRestrictedAccessConstructorRequestor nameRequestor, int waitingPolicy,
        IProgressMonitor progressMonitor) throws JavaModelException {

    // Validate match rule first
    final int validatedTypeMatchRule = SearchPattern
            .validateMatchRule(typeName == null ? null : new String(typeName), typeMatchRule);

    final int pkgMatchRule = SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE;
    final char NoSuffix = IIndexConstants.TYPE_SUFFIX; // Used as TYPE_SUFFIX has no effect in method #match(char, char[] , int, char[], int , int, char[], char[])

    // Debug/*from   w  ww.  ja  va  2  s.co  m*/
    if (VERBOSE) {
        Util.verbose(
                "BasicSearchEngine.searchAllConstructorDeclarations(char[], char[], int, IJavaSearchScope, IRestrictedAccessConstructorRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
        Util.verbose("   - package name: " + (packageName == null ? "null" : new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - type name: " + (typeName == null ? "null" : new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - type match rule: " + getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
        if (validatedTypeMatchRule != typeMatchRule) {
            Util.verbose("   - validated type match rule: " + getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
        }
        Util.verbose("   - scope: " + scope); //$NON-NLS-1$
    }
    if (validatedTypeMatchRule == -1)
        return; // invalid match rule => return no results

    // Create pattern
    final ConstructorDeclarationPattern pattern = new ConstructorDeclarationPattern(packageName, typeName,
            validatedTypeMatchRule);

    // Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
    final HashSet workingCopyPaths = new HashSet();
    String workingCopyPath = null;
    ICompilationUnit[] copies = getWorkingCopies();
    final int copiesLength = copies == null ? 0 : copies.length;
    if (copies != null) {
        if (copiesLength == 1) {
            workingCopyPath = copies[0].getPath().toString();
        } else {
            for (int i = 0; i < copiesLength; i++) {
                ICompilationUnit workingCopy = copies[i];
                workingCopyPaths.add(workingCopy.getPath().toString());
            }
        }
    }
    final String singleWkcpPath = workingCopyPath;

    // Index requestor
    IndexQueryRequestor searchRequestor = new IndexQueryRequestor() {
        public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord,
                SearchParticipant participant, AccessRuleSet access) {
            // Filter unexpected types
            ConstructorDeclarationPattern record = (ConstructorDeclarationPattern) indexRecord;

            if ((record.extraFlags & ExtraFlags.IsMemberType) != 0) {
                return true; // filter out member classes
            }
            if ((record.extraFlags & ExtraFlags.IsLocalType) != 0) {
                return true; // filter out local and anonymous classes
            }
            switch (copiesLength) {
            case 0:
                break;
            case 1:
                if (singleWkcpPath.equals(documentPath)) {
                    return true; // filter out *the* working copy
                }
                break;
            default:
                if (workingCopyPaths.contains(documentPath)) {
                    return true; // filter out working copies
                }
                break;
            }

            // Accept document path
            AccessRestriction accessRestriction = null;
            if (access != null) {
                // Compute document relative path
                int pkgLength = (record.declaringPackageName == null || record.declaringPackageName.length == 0)
                        ? 0
                        : record.declaringPackageName.length + 1;
                int nameLength = record.declaringSimpleName == null ? 0 : record.declaringSimpleName.length;
                char[] path = new char[pkgLength + nameLength];
                int pos = 0;
                if (pkgLength > 0) {
                    System.arraycopy(record.declaringPackageName, 0, path, pos, pkgLength - 1);
                    CharOperation.replace(path, '.', '/');
                    path[pkgLength - 1] = '/';
                    pos += pkgLength;
                }
                if (nameLength > 0) {
                    System.arraycopy(record.declaringSimpleName, 0, path, pos, nameLength);
                    pos += nameLength;
                }
                // Update access restriction if path is not empty
                if (pos > 0) {
                    accessRestriction = access.getViolatedRestriction(path);
                }
            }
            nameRequestor.acceptConstructor(record.modifiers, record.declaringSimpleName, record.parameterCount,
                    record.signature, record.parameterTypes, record.parameterNames,
                    record.declaringTypeModifiers, record.declaringPackageName, record.extraFlags, documentPath,
                    accessRestriction);
            return true;
        }
    };

    try {
        if (progressMonitor != null) {
            progressMonitor.beginTask(Messages.engine_searching, 1000);
        }
        // add type names from indexes
        indexManager.performConcurrentJob(
                new PatternSearchJob(pattern, getDefaultSearchParticipant(indexManager), // Java search only
                        scope, searchRequestor, indexManager),
                waitingPolicy,
                progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000 - copiesLength));

        // add type names from working copies
        if (copies != null) {
            for (int i = 0; i < copiesLength; i++) {
                final ICompilationUnit workingCopy = copies[i];
                if (scope instanceof HierarchyScope) {
                    if (!((HierarchyScope) scope).encloses(workingCopy, progressMonitor))
                        continue;
                } else {
                    if (!scope.encloses(workingCopy))
                        continue;
                }

                final String path = workingCopy.getPath().toString();
                if (workingCopy.isConsistent()) {
                    IPackageDeclaration[] packageDeclarations = workingCopy.getPackageDeclarations();
                    char[] packageDeclaration = packageDeclarations.length == 0 ? CharOperation.NO_CHAR
                            : packageDeclarations[0].getElementName().toCharArray();
                    IType[] allTypes = workingCopy.getAllTypes();
                    for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
                        IType type = allTypes[j];
                        char[] simpleName = type.getElementName().toCharArray();
                        if (match(NoSuffix, packageName, pkgMatchRule, typeName, validatedTypeMatchRule,
                                0/*no kind*/, packageDeclaration, simpleName) && !type.isMember()) {

                            int extraFlags = ExtraFlags.getExtraFlags(type);

                            boolean hasConstructor = false;

                            IMethod[] methods = type.getMethods();
                            for (int k = 0; k < methods.length; k++) {
                                IMethod method = methods[k];
                                if (method.isConstructor()) {
                                    hasConstructor = true;

                                    String[] stringParameterNames = method.getParameterNames();
                                    String[] stringParameterTypes = method.getParameterTypes();
                                    int length = stringParameterNames.length;
                                    char[][] parameterNames = new char[length][];
                                    char[][] parameterTypes = new char[length][];
                                    for (int l = 0; l < length; l++) {
                                        parameterNames[l] = stringParameterNames[l].toCharArray();
                                        parameterTypes[l] = Signature.toCharArray(Signature
                                                .getTypeErasure(stringParameterTypes[l]).toCharArray());
                                    }

                                    nameRequestor.acceptConstructor(method.getFlags(), simpleName,
                                            parameterNames.length, null, // signature is not used for source type
                                            parameterTypes, parameterNames, type.getFlags(), packageDeclaration,
                                            extraFlags, path, null);
                                }
                            }

                            if (!hasConstructor) {
                                nameRequestor.acceptConstructor(Flags.AccPublic, simpleName, -1, null, // signature is not used for source type
                                        CharOperation.NO_CHAR_CHAR, CharOperation.NO_CHAR_CHAR, type.getFlags(),
                                        packageDeclaration, extraFlags, path, null);
                            }
                        }
                    }
                } else {
                    Parser basicParser = getParser();
                    org.eclipse.jdt.internal.compiler.env.ICompilationUnit unit = (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) workingCopy;
                    CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0,
                            this.compilerOptions.maxProblemsPerUnit);
                    CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
                    if (parsedUnit != null) {
                        final char[] packageDeclaration = parsedUnit.currentPackage == null
                                ? CharOperation.NO_CHAR
                                : CharOperation.concatWith(parsedUnit.currentPackage.getImportName(), '.');
                        class AllConstructorDeclarationsVisitor extends ASTVisitor {
                            private TypeDeclaration[] declaringTypes = new TypeDeclaration[0];
                            private int declaringTypesPtr = -1;

                            private void endVisit(TypeDeclaration typeDeclaration) {
                                if (!hasConstructor(typeDeclaration) && typeDeclaration.enclosingType == null) {

                                    if (match(NoSuffix, packageName, pkgMatchRule, typeName,
                                            validatedTypeMatchRule, 0/*no kind*/, packageDeclaration,
                                            typeDeclaration.name)) {
                                        nameRequestor.acceptConstructor(Flags.AccPublic, typeName, -1, null, // signature is not used for source type
                                                CharOperation.NO_CHAR_CHAR, CharOperation.NO_CHAR_CHAR,
                                                typeDeclaration.modifiers, packageDeclaration,
                                                ExtraFlags.getExtraFlags(typeDeclaration), path, null);
                                    }
                                }

                                this.declaringTypes[this.declaringTypesPtr] = null;
                                this.declaringTypesPtr--;
                            }

                            public void endVisit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
                                endVisit(typeDeclaration);
                            }

                            public void endVisit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
                                endVisit(memberTypeDeclaration);
                            }

                            private boolean hasConstructor(TypeDeclaration typeDeclaration) {
                                AbstractMethodDeclaration[] methods = typeDeclaration.methods;
                                int length = methods == null ? 0 : methods.length;
                                for (int j = 0; j < length; j++) {
                                    if (methods[j].isConstructor()) {
                                        return true;
                                    }
                                }

                                return false;
                            }

                            public boolean visit(ConstructorDeclaration constructorDeclaration,
                                    ClassScope classScope) {
                                TypeDeclaration typeDeclaration = this.declaringTypes[this.declaringTypesPtr];
                                if (match(NoSuffix, packageName, pkgMatchRule, typeName, validatedTypeMatchRule,
                                        0/*no kind*/, packageDeclaration, typeDeclaration.name)) {
                                    Argument[] arguments = constructorDeclaration.arguments;
                                    int length = arguments == null ? 0 : arguments.length;
                                    char[][] parameterNames = new char[length][];
                                    char[][] parameterTypes = new char[length][];
                                    for (int l = 0; l < length; l++) {
                                        Argument argument = arguments[l];
                                        parameterNames[l] = argument.name;
                                        if (argument.type instanceof SingleTypeReference) {
                                            parameterTypes[l] = ((SingleTypeReference) argument.type).token;
                                        } else {
                                            parameterTypes[l] = CharOperation.concatWith(
                                                    ((QualifiedTypeReference) argument.type).tokens, '.');
                                        }
                                    }

                                    TypeDeclaration enclosing = typeDeclaration.enclosingType;
                                    char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
                                    while (enclosing != null) {
                                        enclosingTypeNames = CharOperation.arrayConcat(
                                                new char[][] { enclosing.name }, enclosingTypeNames);
                                        if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
                                            enclosing = enclosing.enclosingType;
                                        } else {
                                            enclosing = null;
                                        }
                                    }

                                    nameRequestor.acceptConstructor(constructorDeclaration.modifiers, typeName,
                                            parameterNames.length, null, // signature is not used for source type
                                            parameterTypes, parameterNames, typeDeclaration.modifiers,
                                            packageDeclaration, ExtraFlags.getExtraFlags(typeDeclaration), path,
                                            null);
                                }
                                return false; // no need to find constructors from local/anonymous type
                            }

                            public boolean visit(TypeDeclaration typeDeclaration, BlockScope blockScope) {
                                return false;
                            }

                            private boolean visit(TypeDeclaration typeDeclaration) {
                                if (this.declaringTypes.length <= ++this.declaringTypesPtr) {
                                    int length = this.declaringTypesPtr;
                                    System.arraycopy(this.declaringTypes, 0,
                                            this.declaringTypes = new TypeDeclaration[length * 2 + 1], 0,
                                            length);
                                }
                                this.declaringTypes[this.declaringTypesPtr] = typeDeclaration;
                                return true;
                            }

                            public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
                                return visit(typeDeclaration);
                            }

                            public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
                                return visit(memberTypeDeclaration);
                            }
                        }
                        parsedUnit.traverse(new AllConstructorDeclarationsVisitor(), parsedUnit.scope);
                    }
                }
                if (progressMonitor != null) {
                    if (progressMonitor.isCanceled())
                        throw new OperationCanceledException();
                    progressMonitor.worked(1);
                }
            }
        }
    } finally {
        if (progressMonitor != null) {
            progressMonitor.done();
        }
    }
}

---

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

License:Open Source License

/**
 * Searches for all secondary types in the given scope.
 * The search can be selecting specific types (given a package or a type name
 * prefix and match modes).//ww  w.  ja va  2  s . c om
 */
public void searchAllSecondaryTypeNames(IPackageFragmentRoot[] sourceFolders,
        final IRestrictedAccessTypeRequestor nameRequestor, boolean waitForIndexes,
        IProgressMonitor progressMonitor) throws JavaModelException {

    if (VERBOSE) {
        Util.verbose(
                "BasicSearchEngine.searchAllSecondaryTypeNames(IPackageFragmentRoot[], IRestrictedAccessTypeRequestor, boolean, "
                        + "IProgressMonitor)"); //$NON-NLS-1$
        StringBuffer buffer = new StringBuffer("   - source folders: "); //$NON-NLS-1$
        int length = sourceFolders.length;
        for (int i = 0; i < length; i++) {
            if (i == 0) {
                buffer.append('[');
            } else {
                buffer.append(',');
            }
            buffer.append(sourceFolders[i].getElementName());
        }
        buffer.append("]\n   - waitForIndexes: "); //$NON-NLS-1$
        buffer.append(waitForIndexes);
        Util.verbose(buffer.toString());
    }

    final TypeDeclarationPattern pattern = new SecondaryTypeDeclarationPattern();

    // Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
    final HashSet workingCopyPaths = new HashSet();
    String workingCopyPath = null;
    ICompilationUnit[] copies = getWorkingCopies();
    final int copiesLength = copies == null ? 0 : copies.length;
    if (copies != null) {
        if (copiesLength == 1) {
            workingCopyPath = copies[0].getPath().toString();
        } else {
            for (int i = 0; i < copiesLength; i++) {
                ICompilationUnit workingCopy = copies[i];
                workingCopyPaths.add(workingCopy.getPath().toString());
            }
        }
    }
    final String singleWkcpPath = workingCopyPath;

    // Index requestor
    IndexQueryRequestor searchRequestor = new IndexQueryRequestor() {
        public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord,
                SearchParticipant participant, AccessRuleSet access) {
            // Filter unexpected types
            TypeDeclarationPattern record = (TypeDeclarationPattern) indexRecord;
            if (!record.secondary) {
                return true; // filter maint types
            }
            if (record.enclosingTypeNames == IIndexConstants.ONE_ZERO_CHAR) {
                return true; // filter out local and anonymous classes
            }
            switch (copiesLength) {
            case 0:
                break;
            case 1:
                if (singleWkcpPath.equals(documentPath)) {
                    return true; // fliter out *the* working copy
                }
                break;
            default:
                if (workingCopyPaths.contains(documentPath)) {
                    return true; // filter out working copies
                }
                break;
            }

            // Accept document path
            AccessRestriction accessRestriction = null;
            if (access != null) {
                // Compute document relative path
                int pkgLength = (record.pkg == null || record.pkg.length == 0) ? 0 : record.pkg.length + 1;
                int nameLength = record.simpleName == null ? 0 : record.simpleName.length;
                char[] path = new char[pkgLength + nameLength];
                int pos = 0;
                if (pkgLength > 0) {
                    System.arraycopy(record.pkg, 0, path, pos, pkgLength - 1);
                    CharOperation.replace(path, '.', '/');
                    path[pkgLength - 1] = '/';
                    pos += pkgLength;
                }
                if (nameLength > 0) {
                    System.arraycopy(record.simpleName, 0, path, pos, nameLength);
                    pos += nameLength;
                }
                // Update access restriction if path is not empty
                if (pos > 0) {
                    accessRestriction = access.getViolatedRestriction(path);
                }
            }
            nameRequestor.acceptType(record.modifiers, record.pkg, record.simpleName, record.enclosingTypeNames,
                    documentPath, accessRestriction);
            return true;
        }
    };

    // add type names from indexes
    try {
        if (progressMonitor != null) {
            progressMonitor.beginTask(Messages.engine_searching, 100);
        }
        indexManager.performConcurrentJob(
                new PatternSearchJob(pattern, getDefaultSearchParticipant(indexManager), // Java search only
                        createJavaSearchScope(sourceFolders), searchRequestor, indexManager),
                waitForIndexes ? IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH
                        : IJavaSearchConstants.FORCE_IMMEDIATE_SEARCH,
                progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 100));
    } catch (OperationCanceledException oce) {
        // do nothing
    } finally {
        if (progressMonitor != null) {
            progressMonitor.done();
        }
    }
}

---

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

License:Open Source License

/**
 * Searches for all top-level types and member types in the given scope.
 * The search can be selecting specific types (given a package or a type name
 * prefix and match modes).//from   www  .j  av  a  2  s  .c  o m
 *
 * @see org.eclipse.jdt.core.search.SearchEngine#searchAllTypeNames(char[], int, char[], int, int,
 * org.eclipse.jdt.core.search.IJavaSearchScope, org.eclipse.jdt.core.search.TypeNameRequestor, int,
 * org.eclipse.core.runtime.IProgressMonitor)
 *    for detailed comment
 */
public void searchAllTypeNames(final char[] packageName, final int packageMatchRule, final char[] typeName,
        final int typeMatchRule, int searchFor, IJavaSearchScope scope,
        final IRestrictedAccessTypeRequestor nameRequestor, int waitingPolicy, IProgressMonitor progressMonitor)
        throws JavaModelException {

    // Validate match rule first
    final int validatedTypeMatchRule = SearchPattern
            .validateMatchRule(typeName == null ? null : new String(typeName), typeMatchRule);

    // Debug
    if (VERBOSE) {
        Util.verbose(
                "BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, "
                        + "int, IProgressMonitor)"); //$NON-NLS-1$
        Util.verbose("   - package name: " + (packageName == null ? "null" : new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - package match rule: " + getMatchRuleString(packageMatchRule)); //$NON-NLS-1$
        Util.verbose("   - type name: " + (typeName == null ? "null" : new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - type match rule: " + getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
        if (validatedTypeMatchRule != typeMatchRule) {
            Util.verbose("   - validated type match rule: " + getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
        }
        Util.verbose("   - search for: " + searchFor); //$NON-NLS-1$
        Util.verbose("   - scope: " + scope); //$NON-NLS-1$
    }
    if (validatedTypeMatchRule == -1)
        return; // invalid match rule => return no results

    final char typeSuffix;
    switch (searchFor) {
    case IJavaSearchConstants.CLASS:
        typeSuffix = IIndexConstants.CLASS_SUFFIX;
        break;
    case IJavaSearchConstants.CLASS_AND_INTERFACE:
        typeSuffix = IIndexConstants.CLASS_AND_INTERFACE_SUFFIX;
        break;
    case IJavaSearchConstants.CLASS_AND_ENUM:
        typeSuffix = IIndexConstants.CLASS_AND_ENUM_SUFFIX;
        break;
    case IJavaSearchConstants.INTERFACE:
        typeSuffix = IIndexConstants.INTERFACE_SUFFIX;
        break;
    case IJavaSearchConstants.INTERFACE_AND_ANNOTATION:
        typeSuffix = IIndexConstants.INTERFACE_AND_ANNOTATION_SUFFIX;
        break;
    case IJavaSearchConstants.ENUM:
        typeSuffix = IIndexConstants.ENUM_SUFFIX;
        break;
    case IJavaSearchConstants.ANNOTATION_TYPE:
        typeSuffix = IIndexConstants.ANNOTATION_TYPE_SUFFIX;
        break;
    default:
        typeSuffix = IIndexConstants.TYPE_SUFFIX;
        break;
    }
    final TypeDeclarationPattern pattern = packageMatchRule == SearchPattern.R_EXACT_MATCH
            ? new TypeDeclarationPattern(packageName, null, typeName, typeSuffix, validatedTypeMatchRule)
            : new QualifiedTypeDeclarationPattern(packageName, packageMatchRule, typeName, typeSuffix,
                    validatedTypeMatchRule);

    // Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
    final HashSet workingCopyPaths = new HashSet();
    String workingCopyPath = null;
    ICompilationUnit[] copies = getWorkingCopies();
    final int copiesLength = copies == null ? 0 : copies.length;
    if (copies != null) {
        if (copiesLength == 1) {
            workingCopyPath = copies[0].getPath().toString();
        } else {
            for (int i = 0; i < copiesLength; i++) {
                ICompilationUnit workingCopy = copies[i];
                workingCopyPaths.add(workingCopy.getPath().toString());
            }
        }
    }
    final String singleWkcpPath = workingCopyPath;

    // Index requestor
    IndexQueryRequestor searchRequestor = new IndexQueryRequestor() {
        public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord,
                SearchParticipant participant, AccessRuleSet access) {
            // Filter unexpected types
            TypeDeclarationPattern record = (TypeDeclarationPattern) indexRecord;
            if (record.enclosingTypeNames == IIndexConstants.ONE_ZERO_CHAR) {
                return true; // filter out local and anonymous classes
            }
            switch (copiesLength) {
            case 0:
                break;
            case 1:
                if (singleWkcpPath.equals(documentPath)) {
                    return true; // filter out *the* working copy
                }
                break;
            default:
                if (workingCopyPaths.contains(documentPath)) {
                    return true; // filter out working copies
                }
                break;
            }

            // Accept document path
            AccessRestriction accessRestriction = null;
            if (access != null) {
                // Compute document relative path
                int pkgLength = (record.pkg == null || record.pkg.length == 0) ? 0 : record.pkg.length + 1;
                int nameLength = record.simpleName == null ? 0 : record.simpleName.length;
                char[] path = new char[pkgLength + nameLength];
                int pos = 0;
                if (pkgLength > 0) {
                    System.arraycopy(record.pkg, 0, path, pos, pkgLength - 1);
                    CharOperation.replace(path, '.', '/');
                    path[pkgLength - 1] = '/';
                    pos += pkgLength;
                }
                if (nameLength > 0) {
                    System.arraycopy(record.simpleName, 0, path, pos, nameLength);
                    pos += nameLength;
                }
                // Update access restriction if path is not empty
                if (pos > 0) {
                    accessRestriction = access.getViolatedRestriction(path);
                }
            }
            if (match(record.typeSuffix, record.modifiers)) {
                nameRequestor.acceptType(record.modifiers, record.pkg, record.simpleName,
                        record.enclosingTypeNames, documentPath, accessRestriction);
            }
            return true;
        }
    };

    try {
        if (progressMonitor != null) {
            progressMonitor.beginTask(Messages.engine_searching, 1000);
        }
        // add type names from indexes
        indexManager.performConcurrentJob(
                new PatternSearchJob(pattern, getDefaultSearchParticipant(indexManager), // Java search only
                        scope, searchRequestor, indexManager),
                waitingPolicy,
                progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000 - copiesLength));

        // add type names from working copies
        if (copies != null) {
            for (int i = 0; i < copiesLength; i++) {
                final ICompilationUnit workingCopy = copies[i];
                if (scope instanceof HierarchyScope) {
                    if (!((HierarchyScope) scope).encloses(workingCopy, progressMonitor))
                        continue;
                } else {
                    if (!scope.encloses(workingCopy))
                        continue;
                }
                final String path = workingCopy.getPath().toString();
                if (workingCopy.isConsistent()) {
                    IPackageDeclaration[] packageDeclarations = workingCopy.getPackageDeclarations();
                    char[] packageDeclaration = packageDeclarations.length == 0 ? CharOperation.NO_CHAR
                            : packageDeclarations[0].getElementName().toCharArray();
                    IType[] allTypes = workingCopy.getAllTypes();
                    for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
                        IType type = allTypes[j];
                        IJavaElement parent = type.getParent();
                        char[][] enclosingTypeNames;
                        if (parent instanceof IType) {
                            char[] parentQualifiedName = ((IType) parent).getTypeQualifiedName('.')
                                    .toCharArray();
                            enclosingTypeNames = CharOperation.splitOn('.', parentQualifiedName);
                        } else {
                            enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
                        }
                        char[] simpleName = type.getElementName().toCharArray();
                        int kind;
                        if (type.isEnum()) {
                            kind = TypeDeclaration.ENUM_DECL;
                        } else if (type.isAnnotation()) {
                            kind = TypeDeclaration.ANNOTATION_TYPE_DECL;
                        } else if (type.isClass()) {
                            kind = TypeDeclaration.CLASS_DECL;
                        } else /*if (type.isInterface())*/ {
                            kind = TypeDeclaration.INTERFACE_DECL;
                        }
                        if (match(typeSuffix, packageName, packageMatchRule, typeName, validatedTypeMatchRule,
                                kind, packageDeclaration, simpleName)) {
                            if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
                                ((TypeNameMatchRequestorWrapper) nameRequestor).requestor.acceptTypeNameMatch(
                                        new JavaSearchTypeNameMatch(type, type.getFlags()));
                            } else {
                                nameRequestor.acceptType(type.getFlags(), packageDeclaration, simpleName,
                                        enclosingTypeNames, path, null);
                            }
                        }
                    }
                } else {
                    Parser basicParser = getParser();
                    org.eclipse.jdt.internal.compiler.env.ICompilationUnit unit = (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) workingCopy;
                    CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0,
                            this.compilerOptions.maxProblemsPerUnit);
                    CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
                    if (parsedUnit != null) {
                        final char[] packageDeclaration = parsedUnit.currentPackage == null
                                ? CharOperation.NO_CHAR
                                : CharOperation.concatWith(parsedUnit.currentPackage.getImportName(), '.');
                        class AllTypeDeclarationsVisitor extends ASTVisitor {
                            public boolean visit(TypeDeclaration typeDeclaration, BlockScope blockScope) {
                                return false; // no local/anonymous type
                            }

                            public boolean visit(TypeDeclaration typeDeclaration,
                                    CompilationUnitScope compilationUnitScope) {
                                if (match(typeSuffix, packageName, packageMatchRule, typeName,
                                        validatedTypeMatchRule, TypeDeclaration.kind(typeDeclaration.modifiers),
                                        packageDeclaration, typeDeclaration.name)) {
                                    if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
                                        IType type = workingCopy.getType(new String(typeName));
                                        ((TypeNameMatchRequestorWrapper) nameRequestor).requestor
                                                .acceptTypeNameMatch(new JavaSearchTypeNameMatch(type,
                                                        typeDeclaration.modifiers));
                                    } else {
                                        nameRequestor.acceptType(typeDeclaration.modifiers, packageDeclaration,
                                                typeDeclaration.name, CharOperation.NO_CHAR_CHAR, path, null);
                                    }
                                }
                                return true;
                            }

                            public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
                                if (match(typeSuffix, packageName, packageMatchRule, typeName,
                                        validatedTypeMatchRule,
                                        TypeDeclaration.kind(memberTypeDeclaration.modifiers),
                                        packageDeclaration, memberTypeDeclaration.name)) {
                                    // compute enclosing type names
                                    TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
                                    char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
                                    while (enclosing != null) {
                                        enclosingTypeNames = CharOperation.arrayConcat(
                                                new char[][] { enclosing.name }, enclosingTypeNames);
                                        if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
                                            enclosing = enclosing.enclosingType;
                                        } else {
                                            enclosing = null;
                                        }
                                    }
                                    // report
                                    if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
                                        IType type = workingCopy.getType(new String(enclosingTypeNames[0]));
                                        for (int j = 1, l = enclosingTypeNames.length; j < l; j++) {
                                            type = type.getType(new String(enclosingTypeNames[j]));
                                        }
                                        ((TypeNameMatchRequestorWrapper) nameRequestor).requestor
                                                .acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, 0));
                                    } else {
                                        nameRequestor.acceptType(memberTypeDeclaration.modifiers,
                                                packageDeclaration, memberTypeDeclaration.name,
                                                enclosingTypeNames, path, null);
                                    }
                                }
                                return true;
                            }
                        }
                        parsedUnit.traverse(new AllTypeDeclarationsVisitor(), parsedUnit.scope);
                    }
                }
                if (progressMonitor != null) {
                    if (progressMonitor.isCanceled())
                        throw new OperationCanceledException();
                    progressMonitor.worked(1);
                }
            }
        }
    } finally {
        if (progressMonitor != null) {
            progressMonitor.done();
        }
    }
}

---

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

License:Open Source License

/**
 * Searches for all top-level types and member types in the given scope using  a case sensitive exact match
 * with the given qualified names and type names.
 *
 * @see org.eclipse.jdt.core.search.SearchEngine#searchAllTypeNames(char[][], char[][], org.eclipse.jdt.core.search.IJavaSearchScope,
 * org.eclipse.jdt.core.search.TypeNameRequestor, int, org.eclipse.core.runtime.IProgressMonitor)
 *    for detailed comment//w w w.j  a  va2s .  c o  m
 */
public void searchAllTypeNames(final char[][] qualifications, final char[][] typeNames, final int matchRule,
        int searchFor, IJavaSearchScope scope, final IRestrictedAccessTypeRequestor nameRequestor,
        int waitingPolicy, IProgressMonitor progressMonitor) throws JavaModelException {

    // Debug
    if (VERBOSE) {
        Util.verbose(
                "BasicSearchEngine.searchAllTypeNames(char[][], char[][], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
        Util.verbose("   - package name: " + (qualifications == null ? "null"
                : new String(CharOperation.concatWith(qualifications, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - type name: "
                + (typeNames == null ? "null" : new String(CharOperation.concatWith(typeNames, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
        Util.verbose("   - match rule: " + getMatchRuleString(matchRule)); //$NON-NLS-1$
        Util.verbose("   - search for: " + searchFor); //$NON-NLS-1$
        Util.verbose("   - scope: " + scope); //$NON-NLS-1$
    }

    // Create pattern
    final char typeSuffix;
    switch (searchFor) {
    case IJavaSearchConstants.CLASS:
        typeSuffix = IIndexConstants.CLASS_SUFFIX;
        break;
    case IJavaSearchConstants.CLASS_AND_INTERFACE:
        typeSuffix = IIndexConstants.CLASS_AND_INTERFACE_SUFFIX;
        break;
    case IJavaSearchConstants.CLASS_AND_ENUM:
        typeSuffix = IIndexConstants.CLASS_AND_ENUM_SUFFIX;
        break;
    case IJavaSearchConstants.INTERFACE:
        typeSuffix = IIndexConstants.INTERFACE_SUFFIX;
        break;
    case IJavaSearchConstants.INTERFACE_AND_ANNOTATION:
        typeSuffix = IIndexConstants.INTERFACE_AND_ANNOTATION_SUFFIX;
        break;
    case IJavaSearchConstants.ENUM:
        typeSuffix = IIndexConstants.ENUM_SUFFIX;
        break;
    case IJavaSearchConstants.ANNOTATION_TYPE:
        typeSuffix = IIndexConstants.ANNOTATION_TYPE_SUFFIX;
        break;
    default:
        typeSuffix = IIndexConstants.TYPE_SUFFIX;
        break;
    }
    final MultiTypeDeclarationPattern pattern = new MultiTypeDeclarationPattern(qualifications, typeNames,
            typeSuffix, matchRule);

    // Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
    final HashSet workingCopyPaths = new HashSet();
    String workingCopyPath = null;
    ICompilationUnit[] copies = getWorkingCopies();
    final int copiesLength = copies == null ? 0 : copies.length;
    if (copies != null) {
        if (copiesLength == 1) {
            workingCopyPath = copies[0].getPath().toString();
        } else {
            for (int i = 0; i < copiesLength; i++) {
                ICompilationUnit workingCopy = copies[i];
                workingCopyPaths.add(workingCopy.getPath().toString());
            }
        }
    }
    final String singleWkcpPath = workingCopyPath;

    // Index requestor
    IndexQueryRequestor searchRequestor = new IndexQueryRequestor() {
        public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord,
                SearchParticipant participant, AccessRuleSet access) {
            // Filter unexpected types
            QualifiedTypeDeclarationPattern record = (QualifiedTypeDeclarationPattern) indexRecord;
            if (record.enclosingTypeNames == IIndexConstants.ONE_ZERO_CHAR) {
                return true; // filter out local and anonymous classes
            }
            switch (copiesLength) {
            case 0:
                break;
            case 1:
                if (singleWkcpPath.equals(documentPath)) {
                    return true; // filter out *the* working copy
                }
                break;
            default:
                if (workingCopyPaths.contains(documentPath)) {
                    return true; // filter out working copies
                }
                break;
            }

            // Accept document path
            AccessRestriction accessRestriction = null;
            if (access != null) {
                // Compute document relative path
                int qualificationLength = (record.qualification == null || record.qualification.length == 0) ? 0
                        : record.qualification.length + 1;
                int nameLength = record.simpleName == null ? 0 : record.simpleName.length;
                char[] path = new char[qualificationLength + nameLength];
                int pos = 0;
                if (qualificationLength > 0) {
                    System.arraycopy(record.qualification, 0, path, pos, qualificationLength - 1);
                    CharOperation.replace(path, '.', '/');
                    path[qualificationLength - 1] = '/';
                    pos += qualificationLength;
                }
                if (nameLength > 0) {
                    System.arraycopy(record.simpleName, 0, path, pos, nameLength);
                    pos += nameLength;
                }
                // Update access restriction if path is not empty
                if (pos > 0) {
                    accessRestriction = access.getViolatedRestriction(path);
                }
            }
            nameRequestor.acceptType(record.modifiers, record.pkg, record.simpleName, record.enclosingTypeNames,
                    documentPath, accessRestriction);
            return true;
        }
    };

    try {
        if (progressMonitor != null) {
            progressMonitor.beginTask(Messages.engine_searching, 100);
        }
        // add type names from indexes
        indexManager.performConcurrentJob(
                new PatternSearchJob(pattern, getDefaultSearchParticipant(indexManager), // Java search only
                        scope, searchRequestor, indexManager),
                waitingPolicy, progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 100));

        // add type names from working copies
        if (copies != null) {
            for (int i = 0, length = copies.length; i < length; i++) {
                ICompilationUnit workingCopy = copies[i];
                final String path = workingCopy.getPath().toString();
                if (workingCopy.isConsistent()) {
                    IPackageDeclaration[] packageDeclarations = workingCopy.getPackageDeclarations();
                    char[] packageDeclaration = packageDeclarations.length == 0 ? CharOperation.NO_CHAR
                            : packageDeclarations[0].getElementName().toCharArray();
                    IType[] allTypes = workingCopy.getAllTypes();
                    for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
                        IType type = allTypes[j];
                        IJavaElement parent = type.getParent();
                        char[][] enclosingTypeNames;
                        char[] qualification = packageDeclaration;
                        if (parent instanceof IType) {
                            char[] parentQualifiedName = ((IType) parent).getTypeQualifiedName('.')
                                    .toCharArray();
                            enclosingTypeNames = CharOperation.splitOn('.', parentQualifiedName);
                            qualification = CharOperation.concat(qualification, parentQualifiedName);
                        } else {
                            enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
                        }
                        char[] simpleName = type.getElementName().toCharArray();
                        char suffix = IIndexConstants.TYPE_SUFFIX;
                        if (type.isClass()) {
                            suffix = IIndexConstants.CLASS_SUFFIX;
                        } else if (type.isInterface()) {
                            suffix = IIndexConstants.INTERFACE_SUFFIX;
                        } else if (type.isEnum()) {
                            suffix = IIndexConstants.ENUM_SUFFIX;
                        } else if (type.isAnnotation()) {
                            suffix = IIndexConstants.ANNOTATION_TYPE_SUFFIX;
                        }
                        if (pattern.matchesDecodedKey(new QualifiedTypeDeclarationPattern(qualification,
                                simpleName, suffix, matchRule))) {
                            nameRequestor.acceptType(type.getFlags(), packageDeclaration, simpleName,
                                    enclosingTypeNames, path, null);
                        }
                    }
                } else {
                    Parser basicParser = getParser();
                    org.eclipse.jdt.internal.compiler.env.ICompilationUnit unit = (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) workingCopy;
                    CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0,
                            this.compilerOptions.maxProblemsPerUnit);
                    CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
                    if (parsedUnit != null) {
                        final char[] packageDeclaration = parsedUnit.currentPackage == null
                                ? CharOperation.NO_CHAR
                                : CharOperation.concatWith(parsedUnit.currentPackage.getImportName(), '.');
                        class AllTypeDeclarationsVisitor extends ASTVisitor {
                            public boolean visit(TypeDeclaration typeDeclaration, BlockScope blockScope) {
                                return false; // no local/anonymous type
                            }

                            public boolean visit(TypeDeclaration typeDeclaration,
                                    CompilationUnitScope compilationUnitScope) {
                                SearchPattern decodedPattern = new QualifiedTypeDeclarationPattern(
                                        packageDeclaration, typeDeclaration.name,
                                        convertTypeKind(TypeDeclaration.kind(typeDeclaration.modifiers)),
                                        matchRule);
                                if (pattern.matchesDecodedKey(decodedPattern)) {
                                    nameRequestor.acceptType(typeDeclaration.modifiers, packageDeclaration,
                                            typeDeclaration.name, CharOperation.NO_CHAR_CHAR, path, null);
                                }
                                return true;
                            }

                            public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
                                // compute enclosing type names
                                char[] qualification = packageDeclaration;
                                TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
                                char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
                                while (enclosing != null) {
                                    qualification = CharOperation.concat(qualification, enclosing.name, '.');
                                    enclosingTypeNames = CharOperation
                                            .arrayConcat(new char[][] { enclosing.name }, enclosingTypeNames);
                                    if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
                                        enclosing = enclosing.enclosingType;
                                    } else {
                                        enclosing = null;
                                    }
                                }
                                SearchPattern decodedPattern = new QualifiedTypeDeclarationPattern(
                                        qualification, memberTypeDeclaration.name,
                                        convertTypeKind(TypeDeclaration.kind(memberTypeDeclaration.modifiers)),
                                        matchRule);
                                if (pattern.matchesDecodedKey(decodedPattern)) {
                                    nameRequestor.acceptType(memberTypeDeclaration.modifiers,
                                            packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames,
                                            path, null);
                                }
                                return true;
                            }
                        }
                        parsedUnit.traverse(new AllTypeDeclarationsVisitor(), parsedUnit.scope);
                    }
                }
            }
        }
    } finally {
        if (progressMonitor != null) {
            progressMonitor.done();
        }
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.search.indexing.BinaryIndexer.java

License:Open Source License

public void indexDocument() {
    try {/*from   www  .j av  a  2s.  co  m*/
        final byte[] contents = this.document.getByteContents();
        // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=107124
        // contents can potentially be null if a IOException occurs while retrieving the contents
        if (contents == null)
            return;
        final String path = this.document.getPath();
        ClassFileReader reader = new ClassFileReader(contents, path == null ? null : path.toCharArray());

        // first add type references
        char[] className = replace('/', '.', reader.getName()); // looks like java/lang/String
        // need to extract the package name and the simple name
        int packageNameIndex = CharOperation.lastIndexOf('.', className);
        char[] packageName = null;
        char[] name = null;
        if (packageNameIndex >= 0) {
            packageName = CharOperation.subarray(className, 0, packageNameIndex);
            name = CharOperation.subarray(className, packageNameIndex + 1, className.length);
        } else {
            packageName = CharOperation.NO_CHAR;
            name = className;
        }
        char[] enclosingTypeName = null;
        boolean isNestedType = reader.isNestedType();
        if (isNestedType) {
            if (reader.isAnonymous()) {
                name = CharOperation.NO_CHAR;
            } else {
                name = reader.getInnerSourceName();
            }
            if (reader.isLocal() || reader.isAnonymous()) {
                // set specific ['0'] value for local and anonymous to be able to filter them
                enclosingTypeName = ONE_ZERO;
            } else {
                char[] fullEnclosingName = reader.getEnclosingTypeName();
                int nameLength = fullEnclosingName.length - packageNameIndex - 1;
                if (nameLength <= 0) {
                    // See PR 1GIR345: ITPJCORE:ALL - Indexer: NegativeArraySizeException
                    return;
                }
                enclosingTypeName = new char[nameLength];
                System.arraycopy(fullEnclosingName, packageNameIndex + 1, enclosingTypeName, 0, nameLength);
            }
        }
        // type parameters
        char[][] typeParameterSignatures = null;
        char[] genericSignature = reader.getGenericSignature();
        if (genericSignature != null) {
            CharOperation.replace(genericSignature, '/', '.');
            typeParameterSignatures = Signature.getTypeParameters(genericSignature);
        }

        // eliminate invalid innerclasses (1G4KCF7)
        if (name == null)
            return;

        char[][] superinterfaces = replace('/', '.', reader.getInterfaceNames());
        char[][] enclosingTypeNames = enclosingTypeName == null ? null : new char[][] { enclosingTypeName };
        int modifiers = reader.getModifiers();
        switch (TypeDeclaration.kind(modifiers)) {
        case TypeDeclaration.CLASS_DECL:
            char[] superclass = replace('/', '.', reader.getSuperclassName());
            addClassDeclaration(modifiers, packageName, name, enclosingTypeNames, superclass, superinterfaces,
                    typeParameterSignatures, false);
            break;
        case TypeDeclaration.INTERFACE_DECL:
            addInterfaceDeclaration(modifiers, packageName, name, enclosingTypeNames, superinterfaces,
                    typeParameterSignatures, false);
            break;
        case TypeDeclaration.ENUM_DECL:
            superclass = replace('/', '.', reader.getSuperclassName());
            addEnumDeclaration(modifiers, packageName, name, enclosingTypeNames, superclass, superinterfaces,
                    false);
            break;
        case TypeDeclaration.ANNOTATION_TYPE_DECL:
            addAnnotationTypeDeclaration(modifiers, packageName, name, enclosingTypeNames, false);
            break;
        }

        // Look for references in class annotations
        IBinaryAnnotation[] annotations = reader.getAnnotations();
        if (annotations != null) {
            for (int a = 0, length = annotations.length; a < length; a++) {
                IBinaryAnnotation annotation = annotations[a];
                addBinaryAnnotation(annotation);
            }
        }
        long tagBits = reader.getTagBits() & TagBits.AllStandardAnnotationsMask;
        if (tagBits != 0) {
            addBinaryStandardAnnotations(tagBits);
        }

        int extraFlags = ExtraFlags.getExtraFlags(reader);

        // first reference all methods declarations and field declarations
        MethodInfo[] methods = (MethodInfo[]) reader.getMethods();
        boolean noConstructor = true;
        if (methods != null) {
            for (int i = 0, max = methods.length; i < max; i++) {
                MethodInfo method = methods[i];
                boolean isConstructor = method.isConstructor();
                char[] descriptor = method.getMethodDescriptor();
                char[][] parameterTypes = decodeParameterTypes(descriptor, isConstructor && isNestedType);
                char[] returnType = decodeReturnType(descriptor);
                char[][] exceptionTypes = replace('/', '.', method.getExceptionTypeNames());
                if (isConstructor) {
                    noConstructor = false;
                    char[] signature = method.getGenericSignature();
                    if (signature == null) {
                        if (reader.isNestedType() && ((modifiers & ClassFileConstants.AccStatic) == 0)) {
                            signature = removeFirstSyntheticParameter(descriptor);
                        } else {
                            signature = descriptor;
                        }
                    }
                    addConstructorDeclaration(name, parameterTypes == null ? 0 : parameterTypes.length,
                            signature, parameterTypes, method.getArgumentNames(), method.getModifiers(),
                            packageName, modifiers, exceptionTypes, extraFlags);
                } else {
                    if (!method.isClinit()) {
                        addMethodDeclaration(method.getSelector(), parameterTypes, returnType, exceptionTypes);
                    }
                }
                // look for references in method annotations
                annotations = method.getAnnotations();
                if (annotations != null) {
                    for (int a = 0, length = annotations.length; a < length; a++) {
                        IBinaryAnnotation annotation = annotations[a];
                        addBinaryAnnotation(annotation);
                    }
                }
                tagBits = method.getTagBits() & TagBits.AllStandardAnnotationsMask;
                if (tagBits != 0) {
                    addBinaryStandardAnnotations(tagBits);
                }
            }
        }
        if (noConstructor) {
            addDefaultConstructorDeclaration(className, packageName, modifiers, extraFlags);
        }
        FieldInfo[] fields = (FieldInfo[]) reader.getFields();
        if (fields != null) {
            for (int i = 0, max = fields.length; i < max; i++) {
                FieldInfo field = fields[i];
                char[] fieldName = field.getName();
                char[] fieldType = decodeFieldType(replace('/', '.', field.getTypeName()));
                addFieldDeclaration(fieldType, fieldName);
                // look for references in field annotations
                annotations = field.getAnnotations();
                if (annotations != null) {
                    for (int a = 0, length = annotations.length; a < length; a++) {
                        IBinaryAnnotation annotation = annotations[a];
                        addBinaryAnnotation(annotation);
                    }
                }
                tagBits = field.getTagBits() & TagBits.AllStandardAnnotationsMask;
                if (tagBits != 0) {
                    addBinaryStandardAnnotations(tagBits);
                }
            }
        }
        // record all references found inside the .class file
        extractReferenceFromConstantPool(contents, reader);
    } catch (ClassFormatException e) {
        // ignore
        this.document.removeAllIndexEntries();
        Util.log(IStatus.WARNING, "The Java indexing could not index " + this.document.getPath()
                + ". This .class file doesn't follow the class file format specification. Please report this issue against the .class file vendor"); //$NON-NLS-1$ //$NON-NLS-2$
    } catch (RuntimeException e) {
        // https://bugs.eclipse.org/bugs/show_bug.cgi?id=182154
        // logging the entry that could not be indexed and continue with the next one
        // we remove all entries relative to the boggus document
        this.document.removeAllIndexEntries();
        Util.log(IStatus.WARNING, "The Java indexing could not index " + this.document.getPath()
                + ". This .class file doesn't follow the class file format specification. Please report this issue against the .class file vendor"); //$NON-NLS-1$ //$NON-NLS-2$
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.search.matching.ConstructorDeclarationPattern.java

License:Open Source License

public void decodeIndexKey(char[] key) {
    int last = key.length - 1;
    int slash = CharOperation.indexOf(SEPARATOR, key, 0);
    this.declaringSimpleName = CharOperation.subarray(key, 0, slash);

    int start = slash + 1;
    slash = CharOperation.indexOf(SEPARATOR, key, start);
    last = slash - 1;/*from w  w  w  . ja va 2s.  c om*/

    boolean isDefaultConstructor = key[last] == '#';
    if (isDefaultConstructor) {
        this.parameterCount = -1;
    } else {
        this.parameterCount = 0;
        int power = 1;
        for (int i = last; i >= start; i--) {
            if (i == last) {
                this.parameterCount = key[i] - '0';
            } else {
                power *= 10;
                this.parameterCount += power * (key[i] - '0');
            }
        }
    }

    slash = slash + 3;
    last = slash - 1;

    int typeModifiersWithExtraFlags = key[last - 1] + (key[last] << 16);
    this.declaringTypeModifiers = decodeModifers(typeModifiersWithExtraFlags);
    this.extraFlags = decodeExtraFlags(typeModifiersWithExtraFlags);

    // initialize optional fields
    this.declaringPackageName = null;
    this.modifiers = 0;
    this.signature = null;
    this.parameterTypes = null;
    this.parameterNames = null;

    boolean isMemberType = (this.extraFlags & ExtraFlags.IsMemberType) != 0;

    if (!isMemberType) {
        start = slash + 1;
        if (this.parameterCount == -1) {
            slash = key.length;
            last = slash - 1;
        } else {
            slash = CharOperation.indexOf(SEPARATOR, key, start);
        }
        last = slash - 1;

        this.declaringPackageName = CharOperation.subarray(key, start, slash);

        start = slash + 1;
        if (this.parameterCount == 0) {
            slash = slash + 3;
            last = slash - 1;

            this.modifiers = key[last - 1] + (key[last] << 16);
        } else if (this.parameterCount > 0) {
            slash = CharOperation.indexOf(SEPARATOR, key, start);
            last = slash - 1;

            boolean hasParameterStoredAsSignature = (this.extraFlags
                    & ExtraFlags.ParameterTypesStoredAsSignature) != 0;
            if (hasParameterStoredAsSignature) {
                this.signature = CharOperation.subarray(key, start, slash);
                CharOperation.replace(this.signature, '\\', SEPARATOR);
            } else {
                this.parameterTypes = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
            }
            start = slash + 1;
            slash = CharOperation.indexOf(SEPARATOR, key, start);
            last = slash - 1;

            if (slash != start) {
                this.parameterNames = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
            }

            slash = slash + 3;
            last = slash - 1;

            this.modifiers = key[last - 1] + (key[last] << 16);
        } else {
            this.modifiers = ClassFileConstants.AccPublic;
        }
    }

    removeInternalFlags(); // remove internal flags
}

---

• «
• 1
• 2
• 3
• »