| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| *******************************************************************************/ |
| package org.eclipse.dltk.core.search; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.dltk.ast.declarations.TypeDeclaration; |
| import org.eclipse.dltk.compiler.CharOperation; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.DLTKLanguageManager; |
| import org.eclipse.dltk.core.IDLTKLanguageToolkit; |
| import org.eclipse.dltk.core.IMember; |
| import org.eclipse.dltk.core.IMethod; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IProjectFragment; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.WorkingCopyOwner; |
| import org.eclipse.dltk.core.search.indexing.IIndexConstants; |
| import org.eclipse.dltk.core.search.indexing.IndexManager; |
| import org.eclipse.dltk.core.search.matching.ModuleFactory; |
| import org.eclipse.dltk.internal.compiler.env.AccessRestriction; |
| import org.eclipse.dltk.internal.compiler.env.AccessRuleSet; |
| import org.eclipse.dltk.internal.core.DefaultWorkingCopyOwner; |
| import org.eclipse.dltk.internal.core.ModelManager; |
| import org.eclipse.dltk.internal.core.ScriptProject; |
| import org.eclipse.dltk.internal.core.SourceModule; |
| import org.eclipse.dltk.internal.core.search.DLTKSearchDocument; |
| import org.eclipse.dltk.internal.core.search.DLTKSearchMethodNameMatch; |
| import org.eclipse.dltk.internal.core.search.DLTKSearchScope; |
| import org.eclipse.dltk.internal.core.search.DLTKSearchTypeNameMatch; |
| import org.eclipse.dltk.internal.core.search.HierarchyScope; |
| import org.eclipse.dltk.internal.core.search.IRestrictedAccessMethodRequestor; |
| import org.eclipse.dltk.internal.core.search.IRestrictedAccessTypeRequestor; |
| import org.eclipse.dltk.internal.core.search.IndexQueryRequestor; |
| import org.eclipse.dltk.internal.core.search.PathCollector; |
| import org.eclipse.dltk.internal.core.search.PatternSearchJob; |
| import org.eclipse.dltk.internal.core.search.SuperHierarchyScope; |
| import org.eclipse.dltk.internal.core.search.matching.DLTKSearchPattern; |
| import org.eclipse.dltk.internal.core.search.matching.MethodDeclarationPattern; |
| import org.eclipse.dltk.internal.core.search.matching.QualifiedTypeDeclarationPattern; |
| import org.eclipse.dltk.internal.core.search.matching.TypeDeclarationPattern; |
| import org.eclipse.dltk.internal.core.util.Messages; |
| import org.eclipse.dltk.internal.core.util.Util; |
| import org.eclipse.osgi.util.NLS; |
| |
| /** |
| * Search basic engine. Public search engine now uses basic engine |
| * functionalities. Note that serch basic engine does not implement deprecated |
| * functionalities... |
| */ |
| public class BasicSearchEngine { |
| |
| /* |
| * A default parseor to parse non-reconciled working copies |
| */ |
| |
| /* |
| * A list of working copies that take precedence over their original |
| * compilation units. |
| */ |
| private ISourceModule[] workingCopies; |
| |
| /* |
| * A working copy owner whose working copies will take precedent over their |
| * original compilation units. |
| */ |
| private WorkingCopyOwner workingCopyOwner; |
| |
| /** |
| * For tracing purpose. |
| */ |
| public static boolean VERBOSE = DLTKCore.VERBOSE_SEARCH; |
| |
| /* |
| * Creates a new search basic engine. |
| */ |
| public BasicSearchEngine() { |
| // will use working copies of PRIMARY owner |
| } |
| |
| /** |
| * @see SearchEngine#SearchEngine(ISourceModule[]) for detailed comment. |
| */ |
| public BasicSearchEngine(ISourceModule[] workingCopies) { |
| this.workingCopies = workingCopies; |
| } |
| |
| char convertTypeKind(int typeDeclarationKind) { |
| switch (typeDeclarationKind) { |
| case TypeDeclaration.D_CLASS: |
| return IIndexConstants.TYPE_SUFFIX; |
| default: |
| return IIndexConstants.TYPE_SUFFIX; |
| } |
| } |
| |
| /** |
| * @see SearchEngine#SearchEngine(WorkingCopyOwner) for detailed comment. |
| */ |
| public BasicSearchEngine(WorkingCopyOwner workingCopyOwner) { |
| this.workingCopyOwner = workingCopyOwner; |
| } |
| |
| /** |
| * @see SearchEngine#createHierarchyScope(IType) for detailed comment. |
| */ |
| public static IDLTKSearchScope createHierarchyScope(IType type) |
| throws ModelException { |
| return createHierarchyScope(type, DefaultWorkingCopyOwner.PRIMARY); |
| } |
| |
| /** |
| * @see SearchEngine#createHierarchyScope(IType,WorkingCopyOwner) for |
| * detailed comment. |
| */ |
| public static IDLTKSearchScope createHierarchyScope(IType type, |
| WorkingCopyOwner owner) throws ModelException { |
| IDLTKLanguageToolkit toolkit; |
| toolkit = DLTKLanguageManager.getLanguageToolkit(type); |
| return new HierarchyScope(toolkit, type, owner); |
| } |
| |
| /** |
| * @see SearchEngine#createSuperHierarchyScope(IType) for detailed comment. |
| */ |
| public static IDLTKSearchScope createSuperHierarchyScope(IType type) |
| throws ModelException { |
| return createSuperHierarchyScope(type, DefaultWorkingCopyOwner.PRIMARY); |
| } |
| |
| /** |
| * @see SearchEngine#createSuperHierarchyScope(IType,WorkingCopyOwner) for |
| * detailed comment. |
| */ |
| public static IDLTKSearchScope createSuperHierarchyScope(IType type, |
| WorkingCopyOwner owner) throws ModelException { |
| IDLTKLanguageToolkit toolkit; |
| toolkit = DLTKLanguageManager.getLanguageToolkit(type); |
| return new SuperHierarchyScope(toolkit, type, owner); |
| } |
| |
| /** |
| * @see SearchEngine#createSearchScope(IModelElement[]) for detailed |
| * comment. |
| */ |
| public static IDLTKSearchScope createSearchScope(IModelElement[] elements, |
| IDLTKLanguageToolkit toolkit) { |
| return createSearchScope(elements, true, toolkit); |
| } |
| |
| public static IDLTKSearchScope createSearchScope(IModelElement element) { |
| return createSearchScope(new IModelElement[] { element }, true, |
| DLTKLanguageManager.getLanguageToolkit(element)); |
| } |
| |
| /** |
| * @see SearchEngine#createSearchScope(IModelElement[], boolean) for |
| * detailed comment. |
| */ |
| public static IDLTKSearchScope createSearchScope(IModelElement[] elements, |
| boolean includeReferencedProjects, IDLTKLanguageToolkit toolkit) { |
| int includeMask = IDLTKSearchScope.SOURCES |
| | IDLTKSearchScope.APPLICATION_LIBRARIES |
| | IDLTKSearchScope.SYSTEM_LIBRARIES; |
| if (includeReferencedProjects) { |
| includeMask |= IDLTKSearchScope.REFERENCED_PROJECTS; |
| } |
| return createSearchScope(elements, includeMask, toolkit); |
| } |
| |
| /** |
| * @see SearchEngine#createSearchScope(IModelElement[], int) for detailed |
| * comment. |
| */ |
| public static IDLTKSearchScope createSearchScope(IModelElement[] elements, |
| int includeMask, IDLTKLanguageToolkit toolkit) { |
| |
| DLTKSearchScope scope = new DLTKSearchScope(toolkit); |
| |
| // For EMPTY CASE |
| if (toolkit != null) { |
| HashSet<IProject> visitedProjects = new HashSet<>(2); |
| for (int i = 0; i < elements.length; i++) { |
| IModelElement element = elements[i]; |
| if (element != null) { |
| try { |
| if (element instanceof ScriptProject) { |
| scope.add((ScriptProject) element, includeMask, |
| visitedProjects); |
| } else { |
| scope.add(element); |
| } |
| } catch (ModelException e) { |
| // ignore |
| } |
| } |
| } |
| } |
| return scope; |
| } |
| |
| /** |
| * @see SearchEngine#createTypeNameMatch(IType, int) for detailed comment. |
| */ |
| public static TypeNameMatch createTypeNameMatch(IType type, int modifiers) { |
| return new DLTKSearchTypeNameMatch(type, modifiers); |
| } |
| |
| /** |
| * @see SearchEngine#createWorkspaceScope() for detailed comment. |
| */ |
| public static IDLTKSearchScope createWorkspaceScope( |
| IDLTKLanguageToolkit toolkit) { |
| return ModelManager.getModelManager().getWorkspaceScope(toolkit); |
| } |
| |
| /** |
| * Searches for matches to a given query. Search queries can be created |
| * using helper methods (from a String pattern or a Script element) and |
| * encapsulate the description of what is being searched (for example, |
| * search method declarations in a case sensitive way). |
| * |
| * @param scope |
| * the search result has to be limited to the given scope |
| * @param requestor |
| * a callback object to which each match is reported |
| */ |
| void findMatches(SearchPattern pattern, SearchParticipant[] participants, |
| IDLTKSearchScope scope, SearchRequestor requestor, |
| IProgressMonitor monitor) throws CoreException { |
| if (monitor != null && monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| if (VERBOSE) { |
| Util.verbose("Searching for pattern: " + pattern.toString()); //$NON-NLS-1$ |
| Util.verbose(scope.toString()); |
| } |
| if (participants == null) { |
| if (VERBOSE) { |
| Util.verbose("No participants => do nothing!"); //$NON-NLS-1$ |
| } |
| return; |
| } |
| int length = participants.length; |
| if (monitor != null) |
| monitor.beginTask(Messages.engine_searching, 100 * length); |
| |
| IndexManager indexManager = ModelManager.getModelManager() |
| .getIndexManager(); |
| try { |
| requestor.beginReporting(); |
| for (int i = 0; i < participants.length; i++) { |
| SearchParticipant participant = participants[i]; |
| if (monitor != null && monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| try { |
| if (monitor != null) |
| monitor.subTask( |
| NLS.bind(Messages.engine_searching_indexing, |
| participant.getDescription())); |
| participant.beginSearching(); |
| requestor.enterParticipant(participant); |
| final String[] indexMatchPaths = collectMatchingPaths( |
| indexManager, pattern, participant, scope, |
| monitor == null ? null |
| : new SubProgressMonitor(monitor, 50)); |
| |
| // locate index matches if any (note that all search matches |
| // could have been issued during index querying) |
| if (monitor != null) |
| monitor.subTask( |
| NLS.bind(Messages.engine_searching_matching, |
| participant.getDescription())); |
| if (indexMatchPaths != null) { |
| int indexMatchLength = indexMatchPaths.length; |
| SearchDocument[] indexMatches = new SearchDocument[indexMatchLength]; |
| for (int j = 0; j < indexMatchLength; j++) { |
| indexMatches[j] = participant |
| .getDocument(indexMatchPaths[j], null); |
| } |
| SearchDocument[] matches = ModuleFactory |
| .addWorkingCopies(pattern, indexMatches, |
| getWorkingCopies(), participant); |
| final Set<IPath> paths = new HashSet<>(); |
| List<SearchDocument> filteredMatches = new ArrayList<>(); |
| for (int q = 0; q < matches.length; ++q) { |
| IPath path = new Path(matches[q].getPath()); |
| if (paths.add(path)) { |
| filteredMatches.add(matches[q]); |
| } |
| } |
| SearchDocument[] fmatches = filteredMatches.toArray( |
| new SearchDocument[filteredMatches.size()]); |
| participant.locateMatches(fmatches, pattern, scope, |
| requestor, monitor == null ? null |
| : new SubProgressMonitor(monitor, 50)); |
| } |
| } catch (Exception e) { |
| DLTKCore.error("Error in findMatches()", e); //$NON-NLS-1$ |
| } finally { |
| requestor.exitParticipant(participant); |
| participant.doneSearching(); |
| } |
| } |
| } catch (Exception e) { |
| DLTKCore.error("Error in findMatches()", e); //$NON-NLS-1$ |
| } finally { |
| requestor.endReporting(); |
| if (monitor != null) { |
| monitor.done(); |
| } |
| } |
| } |
| |
| private String[] collectMatchingPaths(IndexManager indexManager, |
| SearchPattern pattern, SearchParticipant participant, |
| IDLTKSearchScope scope, IProgressMonitor monitor) { |
| final PathCollector pathCollector = new PathCollector(); |
| indexManager.performConcurrentJob( |
| new PatternSearchJob(pattern, participant, scope, |
| pathCollector), |
| IDLTKSearchConstants.WAIT_UNTIL_READY_TO_SEARCH, monitor); |
| if (monitor != null && monitor.isCanceled()) |
| throw new OperationCanceledException(); |
| return pathCollector.getPaths(); |
| } |
| |
| List findMatchesSourceOnly(SearchPattern pattern, |
| SearchParticipant[] participants, IDLTKSearchScope scope, |
| IProgressMonitor monitor) throws CoreException { |
| if (monitor != null && monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| /* initialize progress monitor */ |
| if (monitor != null) { |
| monitor.beginTask(Messages.engine_searching, 100); |
| } |
| if (VERBOSE) { |
| Util.verbose("Searching for pattern: " + pattern.toString()); //$NON-NLS-1$ |
| Util.verbose(scope.toString()); |
| } |
| if (participants == null) { |
| if (VERBOSE) { |
| Util.verbose("No participants => do nothing!"); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| |
| IndexManager indexManager = ModelManager.getModelManager() |
| .getIndexManager(); |
| try { |
| List documents = new ArrayList(); |
| for (int i = 0; i < participants.length; i++) { |
| SearchParticipant participant = participants[i]; |
| if (monitor != null && monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| SubProgressMonitor subMonitor = monitor == null ? null |
| : new SubProgressMonitor(monitor, 1000); |
| if (subMonitor != null) { |
| subMonitor.beginTask("", 1000); //$NON-NLS-1$ |
| } |
| try { |
| if (subMonitor != null) { |
| subMonitor.subTask( |
| NLS.bind(Messages.engine_searching_indexing, |
| participant.getDescription())); |
| } |
| participant.beginSearching(); |
| final String[] indexMatchPaths = collectMatchingPaths( |
| indexManager, pattern, participant, scope, |
| subMonitor); |
| |
| if (indexMatchPaths != null) { |
| // locate index matches if any (note that all search |
| // matches |
| // could have been issued during index querying) |
| if (subMonitor != null) { |
| subMonitor.subTask( |
| NLS.bind(Messages.engine_searching_matching, |
| participant.getDescription())); |
| } |
| int indexMatchLength = indexMatchPaths.length; |
| SearchDocument[] indexMatches = new SearchDocument[indexMatchLength]; |
| for (int j = 0; j < indexMatchLength; j++) { |
| indexMatches[j] = participant |
| .getDocument(indexMatchPaths[j], null); |
| } |
| SearchDocument[] matches = ModuleFactory |
| .addWorkingCopies(pattern, indexMatches, |
| getWorkingCopies(), participant); |
| ISourceModule[] modules = participant |
| .locateModules(matches, scope, subMonitor); |
| for (int k = 0; k < modules.length; ++k) { |
| if (!documents.contains(modules[k])) { |
| documents.add(modules[k]); |
| } |
| } |
| } |
| } catch (Exception e) { |
| DLTKCore.error("Error in findMatchesSourceOnly()", e); //$NON-NLS-1$ |
| } finally { |
| participant.doneSearching(); |
| } |
| return documents; |
| } |
| |
| } catch (Exception e) { |
| DLTKCore.error("Error in findMatchesSourceOnly()", e); //$NON-NLS-1$ |
| } finally { |
| if (monitor != null) { |
| monitor.done(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a new default Script search participant. |
| * |
| * @return a new default Script search participant |
| * |
| */ |
| public static SearchParticipant getDefaultSearchParticipant() { |
| return new DLTKSearchParticipant(); |
| } |
| |
| /** |
| * @param matchRule |
| */ |
| public static String getMatchRuleString(final int matchRule) { |
| if (matchRule == 0) { |
| return "R_EXACT_MATCH"; //$NON-NLS-1$ |
| } |
| StringBuffer buffer = new StringBuffer(); |
| for (int i = 1; i <= 8; i++) { |
| int bit = matchRule & (1 << (i - 1)); |
| if (bit != 0 && buffer.length() > 0) { |
| buffer.append(" | "); //$NON-NLS-1$ |
| } |
| switch (bit) { |
| case SearchPattern.R_PREFIX_MATCH: |
| buffer.append("R_PREFIX_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_CASE_SENSITIVE: |
| buffer.append("R_CASE_SENSITIVE"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_EQUIVALENT_MATCH: |
| buffer.append("R_EQUIVALENT_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_ERASURE_MATCH: |
| buffer.append("R_ERASURE_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_FULL_MATCH: |
| buffer.append("R_FULL_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_PATTERN_MATCH: |
| buffer.append("R_PATTERN_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_REGEXP_MATCH: |
| buffer.append("R_REGEXP_MATCH"); //$NON-NLS-1$ |
| break; |
| case SearchPattern.R_CAMELCASE_MATCH: |
| buffer.append("R_CAMELCASE_MATCH"); //$NON-NLS-1$ |
| break; |
| } |
| } |
| return buffer.toString(); |
| } |
| |
| /** |
| * Return kind of search corresponding to given value. |
| * |
| * @param searchFor |
| */ |
| public static String getSearchForString(final int searchFor) { |
| switch (searchFor) { |
| case IDLTKSearchConstants.TYPE: |
| return ("TYPE"); //$NON-NLS-1$ |
| case IDLTKSearchConstants.METHOD: |
| return ("METHOD"); //$NON-NLS-1$ |
| // case IDLTKSearchConstants.PACKAGE: |
| // return ("PACKAGE"); //$NON-NLS-1$ |
| // case IDLTKSearchConstants.CONSTRUCTOR: |
| // return ("CONSTRUCTOR"); //$NON-NLS-1$ |
| case IDLTKSearchConstants.FIELD: |
| return ("FIELD"); //$NON-NLS-1$ |
| case IDLTKSearchConstants.ANNOTATION_TYPE: |
| return ("ANNOTATION_TYPE"); //$NON-NLS-1$ |
| } |
| return "UNKNOWN"; //$NON-NLS-1$ |
| } |
| |
| // private Parser getParser() { |
| // if (this.parser == null) { |
| // this.compilerOptions = new CompilerOptions(JavaCore.getOptions()); |
| // ProblemReporter problemReporter = |
| // new ProblemReporter( |
| // DefaultErrorHandlingPolicies.proceedWithAllProblems(), |
| // this.compilerOptions, |
| // new DefaultProblemFactory()); |
| // this.parser = new Parser(problemReporter, true); |
| // } |
| // return this.parser; |
| // } |
| |
| /* |
| * Returns the list of working copies used by this search engine. Returns |
| * null if none. |
| */ |
| private ISourceModule[] getWorkingCopies() { |
| ISourceModule[] copies; |
| if (this.workingCopies != null) { |
| if (this.workingCopyOwner == null) { |
| copies = ModelManager.getModelManager().getWorkingCopies( |
| DefaultWorkingCopyOwner.PRIMARY, |
| false/* |
| * don't add primary WCs a second time |
| */); |
| if (copies == null) { |
| copies = this.workingCopies; |
| } else { |
| HashMap pathToCUs = new HashMap(); |
| for (int i = 0; i < copies.length; i++) { |
| ISourceModule unit = copies[i]; |
| pathToCUs.put(unit.getPath(), unit); |
| |
| } |
| for (int i = 0; i < this.workingCopies.length; i++) { |
| ISourceModule unit = this.workingCopies[i]; |
| pathToCUs.put(unit.getPath(), unit); |
| } |
| int length = pathToCUs.size(); |
| copies = new ISourceModule[length]; |
| pathToCUs.values().toArray(copies); |
| } |
| } else { |
| copies = this.workingCopies; |
| } |
| } else if (this.workingCopyOwner != null) { |
| copies = ModelManager.getModelManager().getWorkingCopies( |
| this.workingCopyOwner, true/* add primary WCs */); |
| } else { |
| copies = ModelManager.getModelManager().getWorkingCopies( |
| DefaultWorkingCopyOwner.PRIMARY, |
| false/* |
| * don't add primary WCs a second time |
| */); |
| } |
| if (copies == null) { |
| return null; |
| } |
| |
| // filter out primary working copies that are saved |
| ISourceModule[] result = null; |
| int length = copies.length; |
| int index = 0; |
| for (int i = 0; i < length; i++) { |
| SourceModule copy = (SourceModule) copies[i]; |
| try { |
| if (!copy.isPrimary() || copy.hasUnsavedChanges() |
| || copy.hasResourceChanged()) { |
| if (result == null) { |
| result = new ISourceModule[length]; |
| } |
| result[index++] = copy; |
| } |
| } catch (ModelException e) { |
| // copy doesn't exist: ignore |
| } |
| } |
| if (index != length && result != null) { |
| System.arraycopy(result, 0, result = new ISourceModule[index], 0, |
| index); |
| } |
| return result; |
| } |
| |
| /* |
| * Returns the list of working copies used to do the search on the given |
| * Script element. |
| */ |
| private ISourceModule[] getWorkingCopies(IModelElement element) { |
| if (element instanceof IMember) { |
| ISourceModule cu = ((IMember) element).getSourceModule(); |
| if (cu != null && cu.isWorkingCopy()) { |
| ISourceModule[] copies = getWorkingCopies(); |
| int length = copies == null ? 0 : copies.length; |
| if (length > 0) { |
| ISourceModule[] newWorkingCopies = new ISourceModule[length |
| + 1]; |
| System.arraycopy(copies, 0, newWorkingCopies, 0, length); |
| newWorkingCopies[length] = cu; |
| return newWorkingCopies; |
| } |
| return new ISourceModule[] { cu }; |
| } |
| } |
| return getWorkingCopies(); |
| } |
| |
| boolean match(char patternTypeSuffix, int modifiers) { |
| switch (patternTypeSuffix) { |
| case IIndexConstants.TYPE_SUFFIX: |
| return true; // TODO: add conditions here when needed |
| // case IIndexConstants.ANNOTATION_TYPE_SUFFIX : |
| // return (modifiers & Flags.AccAnnotation) != 0; |
| } |
| return true; |
| } |
| |
| boolean match(char patternTypeSuffix, char[] patternPkg, |
| char[] patternTypeName, int matchRule, int typeKind, char[] pkg, |
| char[] typeName) { |
| |
| boolean isCaseSensitive = (matchRule |
| & SearchPattern.R_CASE_SENSITIVE) != 0; |
| // if (patternPkg != null && !CharOperation.equals(patternPkg, pkg, |
| // isCaseSensitive)) |
| // return false; |
| |
| if (patternTypeName != null) { |
| boolean isCamelCase = (matchRule |
| & SearchPattern.R_CAMELCASE_MATCH) != 0; |
| int matchMode = matchRule & DLTKSearchPattern.MATCH_MODE_MASK; |
| if (!isCaseSensitive && !isCamelCase) { |
| patternTypeName = CharOperation.toLowerCase(patternTypeName); |
| } |
| boolean matchFirstChar = !isCaseSensitive |
| || patternTypeName[0] == typeName[0]; |
| if (isCamelCase && matchFirstChar && CharOperation |
| .camelCaseMatch(patternTypeName, typeName)) { |
| return true; |
| } |
| switch (matchMode) { |
| case SearchPattern.R_EXACT_MATCH: |
| if (!isCamelCase) { |
| return matchFirstChar && CharOperation |
| .equals(patternTypeName, typeName, isCaseSensitive); |
| } |
| // fall through next case to match as prefix if camel case |
| // failed |
| case SearchPattern.R_PREFIX_MATCH: |
| return matchFirstChar && CharOperation.prefixEquals( |
| patternTypeName, typeName, isCaseSensitive); |
| case SearchPattern.R_PATTERN_MATCH: |
| return CharOperation.match(patternTypeName, typeName, |
| isCaseSensitive); |
| case SearchPattern.R_REGEXP_MATCH: |
| // TODO (frederic) implement regular expression match |
| break; |
| } |
| } |
| return true; |
| |
| } |
| |
| /** |
| * Searches for matches of a given search pattern. Search patterns can be |
| * created using helper methods (from a String pattern or a Script element) |
| * and encapsulate the description of what is being searched (for example, |
| * search method declarations in a case sensitive way). |
| * |
| * @see SearchEngine#search(SearchPattern, SearchParticipant[], |
| * IJavaSearchScope, SearchRequestor, IProgressMonitor) for detailed |
| * comment |
| */ |
| public void search(SearchPattern pattern, SearchParticipant[] participants, |
| IDLTKSearchScope scope, SearchRequestor requestor, |
| IProgressMonitor monitor) throws CoreException { |
| if (VERBOSE) { |
| Util.verbose( |
| "BasicSearchEngine.search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, IProgressMonitor)"); //$NON-NLS-1$ |
| } |
| findMatches(pattern, participants, scope, requestor, monitor); |
| } |
| |
| /** |
| * Searches for matches of a given search pattern. Search patterns can be |
| * created using helper methods (from a String pattern or a Script element) |
| * and encapsulate the description of what is being searched (for example, |
| * search method declarations in a case sensitive way). |
| * |
| * @see SearchEngine#search(SearchPattern, SearchParticipant[], |
| * IJavaSearchScope, SearchRequestor, IProgressMonitor) for detailed |
| * comment |
| */ |
| public List searchSourceOnly(SearchPattern pattern, |
| SearchParticipant[] participants, IDLTKSearchScope scope, |
| IProgressMonitor monitor) throws CoreException { |
| if (VERBOSE) { |
| Util.verbose( |
| "BasicSearchEngine.search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, IProgressMonitor)"); //$NON-NLS-1$ |
| } |
| return findMatchesSourceOnly(pattern, participants, scope, monitor); |
| } |
| |
| /** |
| * 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). |
| */ |
| public void searchAllSecondaryTypeNames(IProjectFragment[] sourceFolders, |
| final IRestrictedAccessTypeRequestor nameRequestor, |
| boolean waitForIndexes, IProgressMonitor progressMonitor) |
| throws ModelException { |
| // |
| // if (VERBOSE) { |
| // Util.verbose( |
| // "BasicSearchEngine.searchAllSecondaryTypeNames(IProjectFragment[], |
| // 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()); |
| // } |
| // |
| // IndexManager indexManager = |
| // ModelManager.getModelManager().getIndexManager(); |
| // 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; |
| // ISourceModule[] 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++) { |
| // ISourceModule 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 |
| // if (progressMonitor != null) { |
| // progressMonitor.beginTask(Messages.engine_searching, 100); |
| // } |
| // try { |
| // indexManager.performConcurrentJob( |
| // new PatternSearchJob( |
| // pattern, |
| // getDefaultSearchParticipant(), // Script search only |
| // createJavaSearchScope(sourceFolders), |
| // searchRequestor), |
| // waitForIndexes |
| // ? IDLTKSearchConstants.WAIT_UNTIL_READY_TO_SEARCH |
| // : IDLTKSearchConstants.FORCE_IMMEDIATE_SEARCH, |
| // progressMonitor == null ? null : new |
| // SubProgressMonitor(progressMonitor, 100)); |
| // } |
| // catch (OperationCanceledException oce) { |
| // // do nothing |
| // } |
| } |
| |
| /** |
| * 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). |
| * |
| * @see SearchEngine#searchAllTypeNames(char[], char[], int, int, |
| * IJavaSearchScope, TypeNameRequestor, int, IProgressMonitor) for |
| * detailed comment |
| */ |
| public void searchAllTypeNames(final char[] packageName, |
| final int packageMatchRule, char[] typeName, |
| final int typeMatchRule, int searchFor, IDLTKSearchScope scope, |
| final IRestrictedAccessTypeRequestor nameRequestor, |
| int waitingPolicy, IProgressMonitor progressMonitor) |
| throws ModelException { |
| |
| if (VERBOSE) { |
| Util.verbose( |
| "BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$ |
| Util.verbose(" - package name: " //$NON-NLS-1$ |
| + (packageName == null ? "null" : new String(packageName))); //$NON-NLS-1$ |
| Util.verbose( |
| " - match rule: " + getMatchRuleString(packageMatchRule)); //$NON-NLS-1$ |
| Util.verbose(" - type name: " //$NON-NLS-1$ |
| + (typeName == null ? "null" : new String(typeName))); //$NON-NLS-1$ |
| Util.verbose( |
| " - match rule: " + getMatchRuleString(typeMatchRule)); //$NON-NLS-1$ |
| Util.verbose(" - search for: " + searchFor); //$NON-NLS-1$ |
| Util.verbose(" - scope: " + scope); //$NON-NLS-1$ |
| } |
| |
| // Return on invalid combination of package and type names |
| if (packageName == null || packageName.length == 0) { |
| if (typeName != null && typeName.length == 0) { |
| // TODO (frederic) Throw a JME instead? |
| if (VERBOSE) { |
| Util.verbose( |
| " => return no result due to invalid empty values for package and type names!"); //$NON-NLS-1$ |
| } |
| return; |
| } |
| } |
| |
| // Create pattern |
| IndexManager indexManager = ModelManager.getModelManager() |
| .getIndexManager(); |
| final char typeSuffix; |
| switch (searchFor) { |
| case IDLTKSearchConstants.TYPE: |
| typeSuffix = IIndexConstants.TYPE_SUFFIX; |
| break; |
| case IDLTKSearchConstants.ANNOTATION_TYPE: |
| typeSuffix = IIndexConstants.ANNOTATION_TYPE_SUFFIX; |
| break; |
| default: |
| typeSuffix = IIndexConstants.TYPE_SUFFIX; |
| break; |
| } |
| |
| final boolean simple = packageName == null || packageName.length == 0; |
| // packageMatchRule == SearchPattern.R_EXACT_MATCH |
| final TypeDeclarationPattern pattern = simple |
| ? new TypeDeclarationPattern(packageName, null, null, typeName, |
| typeSuffix, typeMatchRule, scope.getLanguageToolkit()) |
| : new QualifiedTypeDeclarationPattern(packageName, |
| packageMatchRule, typeName, typeSuffix, typeMatchRule, |
| scope.getLanguageToolkit()); |
| |
| // Get working copy path(s). Store in a single string in case of only |
| // one to optimize comparison in requestor |
| final HashSet<String> workingCopyPaths = new HashSet<>(); |
| String workingCopyPath = null; |
| ISourceModule[] 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++) { |
| ISourceModule workingCopy = copies[i]; |
| workingCopyPaths.add(workingCopy.getPath().toString()); |
| } |
| } |
| } |
| final String singleWkcpPath = workingCopyPath; |
| // final List documentPathFilter = new ArrayList(); |
| // Index requestor |
| IndexQueryRequestor searchRequestor = new IndexQueryRequestor() { |
| @Override |
| public boolean acceptIndexMatch(String documentPath, |
| SearchPattern indexRecord, SearchParticipant participant, |
| AccessRuleSet access) { |
| // IPath fullPath = new Path(documentPath); |
| // if( documentPathFilter.contains(fullPath)) { |
| // return true; |
| // } |
| // documentPathFilter.add(fullPath); |
| // Filter unexpected types |
| TypeDeclarationPattern record = (TypeDeclarationPattern) indexRecord; |
| // FIXME (alex) filter out local and anonymous classes |
| // 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); |
| } |
| } |
| if (match(record.typeSuffix, record.modifiers)) { |
| nameRequestor.acceptType(record.modifiers, record.pkg, |
| record.simpleName, record.enclosingTypeNames, |
| record.superTypes, 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(), // Script |
| // search |
| // only |
| scope, searchRequestor), |
| waitingPolicy, progressMonitor == null ? null |
| : new SubProgressMonitor(progressMonitor, 100)); |
| |
| // add type names from working copies |
| if (copies != null) { |
| for (int i = 0; i < copiesLength; i++) { |
| ISourceModule workingCopy = copies[i]; |
| 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.getTypes(); |
| for (int j = 0; j < allTypes.length; j++) { |
| IType type = allTypes[i]; |
| IModelElement parent = type.getParent(); |
| final 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(); |
| char[] packageDeclaration = SearchPattern |
| .createPackagePattern(type.getNamespace()); |
| int kind = 0; |
| if (match(typeSuffix, packageName, typeName, |
| typeMatchRule, kind, packageDeclaration, |
| simpleName)) { |
| nameRequestor.acceptType(type.getFlags(), |
| packageDeclaration, simpleName, |
| enclosingTypeNames, |
| CharOperation.stringArrayToCharCharArray( |
| type.getSuperClasses()), |
| path, null); |
| } |
| } |
| // } |
| } |
| } |
| } finally { |
| if (progressMonitor != null) { |
| progressMonitor.done(); |
| } |
| } |
| } |
| |
| /** |
| * 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 SearchEngine#searchAllTypeNames(char[][], char[][], |
| * IJavaSearchScope, TypeNameRequestor, int, IProgressMonitor) for |
| * detailed comment |
| */ |
| public void searchAllTypeNames(final char[][] qualifications, |
| final char[][] typeNames, final int matchRule, int searchFor, |
| IDLTKSearchScope scope, |
| final IRestrictedAccessTypeRequestor nameRequestor, |
| int waitingPolicy, IProgressMonitor progressMonitor) |
| throws ModelException { |
| |
| if (VERBOSE) { |
| Util.verbose( |
| "BasicSearchEngine.searchAllTypeNames(char[][], char[][], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$ |
| Util.verbose(" - package name: " + (qualifications == null ? "null" //$NON-NLS-1$ //$NON-NLS-2$ |
| : new String( |
| CharOperation.concatWith(qualifications, ',')))); |
| Util.verbose(" - type name: " + (typeNames == null ? "null" //$NON-NLS-1$ //$NON-NLS-2$ |
| : new String(CharOperation.concatWith(typeNames, ',')))); |
| Util.verbose(" - match rule: " + matchRule); //$NON-NLS-1$ |
| Util.verbose(" - search for: " + searchFor); //$NON-NLS-1$ |
| Util.verbose(" - scope: " + scope); //$NON-NLS-1$ |
| } |
| // IndexManager indexManager = |
| // ModelManager.getModelManager().getIndexManager(); |
| // |
| // final char typeSuffix; |
| // switch(searchFor){ |
| // case IDLTKSearchConstants.CLASS : |
| // typeSuffix = IIndexConstants.CLASS_SUFFIX; |
| // break; |
| // case IDLTKSearchConstants.CLASS_AND_INTERFACE : |
| // typeSuffix = IIndexConstants.CLASS_AND_INTERFACE_SUFFIX; |
| // break; |
| // case IDLTKSearchConstants.CLASS_AND_ENUM : |
| // typeSuffix = IIndexConstants.CLASS_AND_ENUM_SUFFIX; |
| // break; |
| // case IDLTKSearchConstants.INTERFACE : |
| // typeSuffix = IIndexConstants.INTERFACE_SUFFIX; |
| // break; |
| // case IDLTKSearchConstants.ENUM : |
| // typeSuffix = IIndexConstants.ENUM_SUFFIX; |
| // break; |
| // case IDLTKSearchConstants.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; |
| // ISourceModule[] 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++) { |
| // ISourceModule 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 |
| // 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 |
| // QualifiedTypeDeclarationPattern record = |
| // (QualifiedTypeDeclarationPattern) indexRecord; |
| // 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(), // Script search only |
| // scope, |
| // searchRequestor), |
| // 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++) { |
| // ISourceModule 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]; |
| // IModelElement 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.dltk.internal.compiler.env.ISourceModule unit = |
| // (org.eclipse.dltk.internal.compiler.env.ISourceModule) workingCopy; |
| // CompilationResult compilationUnitResult = new CompilationResult(unit, |
| // 0, 0, this.compilerOptions.maxProblemsPerUnit); |
| // SourceModuleDeclaration 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, |
| // SourceModuleScope 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); |
| // Parser basicParser = getParser(); |
| // org.eclipse.dltk.internal.compiler.env.ISourceModule unit = |
| // (org.eclipse.dltk.internal.compiler.env.ISourceModule) workingCopy; |
| // CompilationResult compilationUnitResult = new CompilationResult(unit, |
| // 0, 0, this.compilerOptions.maxProblemsPerUnit); |
| // SourceModuleDeclaration 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, |
| // SourceModuleScope 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 encloising 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);} |
| // return true; |
| // } |
| // public boolean visit(TypeDeclaration memberTypeDeclaration, |
| // ClassScope classScope) { |
| // // compute encloising 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(); |
| // } |
| // } |
| } |
| |
| public DLTKSearchParticipant getSearchParticipant(IModelElement element) { |
| IDLTKLanguageToolkit toolkit = null; |
| toolkit = DLTKLanguageManager.getLanguageToolkit(element); |
| if (toolkit != null) { |
| DLTKSearchParticipant par = DLTKLanguageManager |
| .createSearchParticipant(toolkit.getNatureId()); |
| if (par != null) { |
| return par; |
| } |
| } |
| return new DLTKSearchParticipant(); |
| } |
| |
| public void searchDeclarations(IModelElement enclosingElement, |
| SearchRequestor requestor, SearchPattern pattern, |
| IProgressMonitor monitor) throws ModelException { |
| if (VERBOSE) { |
| Util.verbose(" - script element: " + enclosingElement); //$NON-NLS-1$ |
| } |
| IDLTKSearchScope scope = createSearchScope( |
| new IModelElement[] { enclosingElement }, |
| DLTKLanguageManager.getLanguageToolkit(enclosingElement)); |
| IResource resource = enclosingElement.getResource(); |
| if (enclosingElement instanceof IMember) { |
| IMember member = (IMember) enclosingElement; |
| ISourceModule cu = member.getSourceModule(); |
| if (cu != null) { |
| resource = cu.getResource(); |
| } else if (((IProjectFragment) member |
| .getAncestor(IModelElement.PROJECT_FRAGMENT)) |
| .isExternal()) { |
| // binary member resource cannot be used as this |
| // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=148215 |
| resource = null; |
| } |
| } |
| try { |
| if (resource instanceof IFile) { |
| try { |
| requestor.beginReporting(); |
| if (VERBOSE) { |
| Util.verbose("Searching for " + pattern + " in " //$NON-NLS-1$//$NON-NLS-2$ |
| + resource.getFullPath()); |
| } |
| SearchParticipant participant = getSearchParticipant( |
| enclosingElement); |
| boolean external = false; |
| IProjectFragment fragment = (IProjectFragment) enclosingElement |
| .getAncestor(IModelElement.PROJECT_FRAGMENT); |
| if (fragment != null) { |
| external = fragment.isExternal(); |
| } |
| char[] contents = Util |
| .getResourceContentsAsCharArray((IFile) resource); |
| SearchDocument[] documents = ModuleFactory.addWorkingCopies( |
| pattern, |
| new SearchDocument[] { new DLTKSearchDocument( |
| enclosingElement.getPath().toString(), |
| contents, participant, external, |
| enclosingElement.getScriptProject() |
| .getProject()) }, |
| getWorkingCopies(enclosingElement), participant); |
| participant.locateMatches(documents, pattern, scope, |
| requestor, monitor); |
| } finally { |
| requestor.endReporting(); |
| } |
| } else { |
| search(pattern, |
| new SearchParticipant[] { |
| getDefaultSearchParticipant() }, |
| scope, requestor, monitor); |
| } |
| } catch (CoreException e) { |
| if (e instanceof ModelException) { |
| throw (ModelException) e; |
| } |
| throw new ModelException(e); |
| } |
| } |
| |
| /** |
| * Searches for all declarations of the fields accessed in the given |
| * element. The element can be a compilation unit, a source type, or a |
| * source method. Reports the field declarations using the given requestor. |
| * |
| * @see SearchEngine#searchDeclarationsOfAccessedFields(IModelElement, |
| * SearchRequestor, IProgressMonitor) for detailed comment |
| */ |
| public void searchDeclarationsOfAccessedFields( |
| IModelElement enclosingElement, SearchRequestor requestor, |
| IProgressMonitor monitor) throws ModelException { |
| // if (VERBOSE) { |
| // Util.verbose( |
| // "BasicSearchEngine.searchDeclarationsOfAccessedFields(IModelElement, |
| // SearchRequestor, SearchPattern, IProgressMonitor)"); //$NON-NLS-1$ |
| // } |
| // SearchPattern pattern = new |
| // DeclarationOfAccessedFieldsPattern(enclosingElement); |
| // searchDeclarations(enclosingElement, requestor, pattern, monitor); |
| } |
| |
| /** |
| * Searches for all declarations of the types referenced in the given |
| * element. The element can be a compilation unit, a source type, or a |
| * source method. Reports the type declarations using the given requestor. |
| * |
| * @see SearchEngine#searchDeclarationsOfReferencedTypes(IModelElement, |
| * SearchRequestor, IProgressMonitor) for detailed comment |
| */ |
| public void searchDeclarationsOfReferencedTypes( |
| IModelElement enclosingElement, SearchRequestor requestor, |
| IProgressMonitor monitor) throws ModelException { |
| // if (VERBOSE) { |
| // Util.verbose( |
| // "BasicSearchEngine.searchDeclarationsOfReferencedTypes(IModelElement, |
| // SearchRequestor, SearchPattern, IProgressMonitor)"); //$NON-NLS-1$ |
| // } |
| // SearchPattern pattern = new |
| // DeclarationOfReferencedTypesPattern(enclosingElement); |
| // searchDeclarations(enclosingElement, requestor, pattern, monitor); |
| } |
| |
| /** |
| * Searches for all declarations of the methods invoked in the given |
| * element. The element can be a compilation unit, a source type, or a |
| * source method. Reports the method declarations using the given requestor. |
| * |
| * @see SearchEngine#searchDeclarationsOfSentMessages(IModelElement, |
| * SearchRequestor, IProgressMonitor) for detailed comment |
| */ |
| public void searchDeclarationsOfSentMessages(IModelElement enclosingElement, |
| SearchRequestor requestor, IProgressMonitor monitor) |
| throws ModelException { |
| // if (VERBOSE) { |
| // Util.verbose( |
| // "BasicSearchEngine.searchDeclarationsOfSentMessages(IModelElement, |
| // SearchRequestor, SearchPattern, IProgressMonitor)"); //$NON-NLS-1$ |
| // } |
| // SearchPattern pattern = new |
| // DeclarationOfReferencedMethodsPattern(enclosingElement); |
| // searchDeclarations(enclosingElement, requestor, pattern, monitor); |
| } |
| |
| /** |
| * @see SearchEngine#createTypeNameMatch(IType, int) for detailed comment. |
| */ |
| public static MethodNameMatch createMethodNameMatch(IMethod method, |
| int modifiers) { |
| return new DLTKSearchMethodNameMatch(method, modifiers); |
| } |
| |
| /** |
| * 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). |
| * |
| * @throws ModelException |
| * |
| * @see SearchEngine#searchAllTypeNames(char[], char[], int, int, |
| * IJavaSearchScope, TypeNameRequestor, int, IProgressMonitor) for |
| * detailed comment |
| */ |
| public void searchAllMethodNames(char[] methodName, int methodMatchRule, |
| int searchFor, IDLTKSearchScope scope, |
| final IRestrictedAccessMethodRequestor nameRequestor, |
| int waitingPolicy, IProgressMonitor progressMonitor) |
| throws ModelException { |
| |
| if (VERBOSE) { |
| Util.verbose( |
| "BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$ |
| Util.verbose(" - method name: " //$NON-NLS-1$ |
| + (methodName == null ? "null" : new String(methodName))); //$NON-NLS-1$ |
| Util.verbose( |
| " - match rule: " + getMatchRuleString(methodMatchRule)); //$NON-NLS-1$ |
| Util.verbose(" - search for: " + searchFor); //$NON-NLS-1$ |
| Util.verbose(" - scope: " + scope); //$NON-NLS-1$ |
| } |
| |
| // Return on invalid combination of package and type names |
| if (methodName != null && methodName.length == 0) { |
| // TODO (frederic) Throw a JME instead? |
| if (VERBOSE) { |
| Util.verbose( |
| " => return no result due to invalid empty values for package and type names!"); //$NON-NLS-1$ |
| } |
| return; |
| } |
| |
| // Create pattern |
| IndexManager indexManager = ModelManager.getModelManager() |
| .getIndexManager(); |
| final MethodDeclarationPattern pattern = new MethodDeclarationPattern( |
| methodName, methodMatchRule, scope.getLanguageToolkit()); |
| |
| // 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; |
| ISourceModule[] 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++) { |
| ISourceModule workingCopy = copies[i]; |
| workingCopyPaths.add(workingCopy.getPath().toString()); |
| } |
| } |
| } |
| final String singleWkcpPath = workingCopyPath; |
| // final List documentPathFilter = new ArrayList(); |
| // Index requestor |
| IndexQueryRequestor searchRequestor = new IndexQueryRequestor() { |
| @Override |
| public boolean acceptIndexMatch(String documentPath, |
| SearchPattern indexRecord, SearchParticipant participant, |
| AccessRuleSet access) { |
| // IPath fullPath = new Path(documentPath); |
| // if( documentPathFilter.contains(fullPath)) { |
| // return true; |
| // } |
| // documentPathFilter.add(fullPath); |
| // Filter unexpected types |
| MethodDeclarationPattern record = (MethodDeclarationPattern) indexRecord; |
| 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; |
| } |
| |
| nameRequestor.acceptMethod(record.modifiers, record.pkg, |
| record.simpleName, record.enclosingTypeNames, |
| record.parameterNames, documentPath); |
| return true; |
| } |
| }; |
| |
| try { |
| if (progressMonitor != null) { |
| progressMonitor.beginTask(Messages.engine_searching, 100); |
| } |
| // add type names from indexes |
| indexManager.performConcurrentJob( |
| new PatternSearchJob(pattern, getDefaultSearchParticipant(), // Script |
| // search |
| // only |
| scope, searchRequestor), |
| waitingPolicy, progressMonitor == null ? null |
| : new SubProgressMonitor(progressMonitor, 100)); |
| |
| // add type names from working copies |
| if (copies != null) { |
| for (int i = 0; i < copiesLength; i++) { |
| ISourceModule workingCopy = copies[i]; |
| 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.getTypes(); |
| for (int j = 0; j < allTypes.length; j++) { |
| IType type = allTypes[i]; |
| IModelElement 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 = 0; |
| // FIXME search working copies |
| // if (match(typeSuffix, packageName, methodName, |
| // methodMatchRule, kind, /* packageDeclaration, */ |
| // simpleName)) { |
| // nameRequestor.acceptMethod(simpleName, path, null); |
| // } |
| } |
| // } |
| } |
| } |
| } finally { |
| if (progressMonitor != null) { |
| progressMonitor.done(); |
| } |
| } |
| |
| } |
| } |
