Example usage for org.eclipse.jdt.internal.compiler ExtraFlags IsLocalType

List of usage examples for org.eclipse.jdt.internal.compiler ExtraFlags IsLocalType

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler ExtraFlags IsLocalType.

Prototype

int IsLocalType

To view the source code for org.eclipse.jdt.internal.compiler ExtraFlags IsLocalType.

Click Source Link

Usage

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//w w w.  j  a va 2  s  .  c  o  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.indexing.SourceIndexerRequestor.java

License:Open Source License

private int getMoreExtraFlags(int extraFlags) {
    if (this.methodDepth > 0) {
        extraFlags |= ExtraFlags.IsLocalType;
    }/*from   w  ww  .j  ava2 s . co m*/
    return extraFlags;
}

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

License:Open Source License

static int decodeExtraFlags(int modifiersWithExtraFlags) {
    int extraFlags = 0;

    if ((modifiersWithExtraFlags & ASTNode.Bit28) != 0) {
        extraFlags |= ExtraFlags.ParameterTypesStoredAsSignature;
    }//from ww  w . j  a v a 2s. c om

    if ((modifiersWithExtraFlags & ASTNode.Bit29) != 0) {
        extraFlags |= ExtraFlags.IsLocalType;
    }

    if ((modifiersWithExtraFlags & ASTNode.Bit30) != 0) {
        extraFlags |= ExtraFlags.IsMemberType;
    }

    if ((modifiersWithExtraFlags & ASTNode.Bit31) != 0) {
        extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
    }

    return extraFlags;
}

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

License:Open Source License

private static int encodeExtraFlags(int extraFlags) {
    int encodedExtraFlags = 0;

    if ((extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0) {
        encodedExtraFlags |= ASTNode.Bit28;
    }/* www .j  a va  2 s.c  o m*/

    if ((extraFlags & ExtraFlags.IsLocalType) != 0) {
        encodedExtraFlags |= ASTNode.Bit29;
    }

    if ((extraFlags & ExtraFlags.IsMemberType) != 0) {
        encodedExtraFlags |= ASTNode.Bit30;
    }
    if ((extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0) {
        encodedExtraFlags |= ASTNode.Bit31;
    }

    return encodedExtraFlags;
}

From source file:org.eclipse.che.jdt.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   ww w  .ja v a  2s  .c  o 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, javaProject), // 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();
        }
    }
}