private static void checkHierarchyOfEnclosedTypes( IType destinationType, RefactoringStatus result, IType type) throws JavaModelException { IType[] enclosedTypes = getAllEnclosedTypes(type); for (int i = 0; i < enclosedTypes.length; i++) { IType enclosedType = enclosedTypes[i]; if (destinationType.getElementName().equals(enclosedType.getElementName())) { String message = Messages.format( RefactoringCoreMessages.MemberCheckUtil_type_name_conflict3, new String[] {getQualifiedLabel(enclosedType), getQualifiedLabel(type)}); RefactoringStatusContext context = JavaStatusContext.create( destinationType.getCompilationUnit(), destinationType.getNameRange()); result.addError(message, context); } if (typeNameExistsInEnclosingTypeChain(destinationType, enclosedType.getElementName())) { String message = Messages.format( RefactoringCoreMessages.MemberCheckUtil_type_name_conflict4, new String[] {getQualifiedLabel(enclosedType), getQualifiedLabel(type)}); RefactoringStatusContext context = JavaStatusContext.create( destinationType.getCompilationUnit(), destinationType.getNameRange()); result.addError(message, context); } } }
@Override protected IType createType() throws JavaModelException { IType result = null; if (isPopupView) { result = createClass("PopupViewImpl", presenter.getElementName() + ".MyView"); workingCopy.createImport(C_POPUP_VIEW_IMPL, null, new NullProgressMonitor()); } else { result = createClass("ViewImpl", presenter.getElementName() + ".MyView"); workingCopy.createImport(C_VIEW_IMPL, null, new NullProgressMonitor()); } return result; }
@Override protected boolean initialize(Object element) { if (element instanceof IType) { IType type = (IType) element; IJavaProject javaProject = (IJavaProject) type.getAncestor(IJavaElement.JAVA_PROJECT); mProject = javaProject.getProject(); IResource manifestResource = mProject.findMember(AdtConstants.WS_SEP + SdkConstants.FN_ANDROID_MANIFEST_XML); if (manifestResource == null || !manifestResource.exists() || !(manifestResource instanceof IFile)) { RefactoringUtil.logInfo( "Invalid or missing the " + SdkConstants.FN_ANDROID_MANIFEST_XML + " in the " + mProject.getName() + " project."); return false; } mManifestFile = (IFile) manifestResource; ManifestData manifestData; manifestData = AndroidManifestHelper.parseForData(mManifestFile); if (manifestData == null) { return false; } mAppPackage = manifestData.getPackage(); mOldFqcn = type.getFullyQualifiedName(); Object destination = getArguments().getDestination(); if (destination instanceof IPackageFragment) { IPackageFragment packageFragment = (IPackageFragment) destination; mNewFqcn = packageFragment.getElementName() + "." + type.getElementName(); } else if (destination instanceof IResource) { try { IPackageFragment[] fragments = javaProject.getPackageFragments(); for (IPackageFragment fragment : fragments) { IResource resource = fragment.getResource(); if (resource.equals(destination)) { mNewFqcn = fragment.getElementName() + '.' + type.getElementName(); break; } } } catch (JavaModelException e) { // pass } } return mOldFqcn != null && mNewFqcn != null; } return false; }
public boolean visit(TypeDeclaration node) { if (null != m_typeFilter) { return node.getName().getIdentifier().equals(m_typeFilter.getElementName()); } else { return true; } }
public synchronized void clearCache(IType elementType) { clearApiForElementType(elementType); String elementName = elementType.getElementName(); if (elementName != null) { _elementNameToTypeCache.remove(elementName); } }
public CodeInsertionDialog(Shell shell, IType type) throws JavaModelException { super(shell); insertPositions = new ArrayList<IJavaElement>(); fLabels = new ArrayList<String>(); System.out.println(type.getElementName() + type.getElementType()); IJavaElement[] members = type.getChildren(); insertPositions.add(members.length > 0 ? members[0] : null); // first insertPositions.add(null); // last fLabels.add(CodeInsertionDialog.firstElement); fLabels.add(CodeInsertionDialog.secondElement); for (int i = 0; i < members.length; i++) { IJavaElement curr = members[i]; String methodLabel = JavaElementLabels.getElementLabel(curr, JavaElementLabels.M_PARAMETER_TYPES); // System.out.println(MessageFormat.format(afterElement, methodLabel)); fLabels.add(MessageFormat.format(afterElement, methodLabel)); insertPositions.add(findSibling(curr, members)); } insertPositions.add(null); // null indicate we want to insert into the last position }
private static boolean typeNameExistsInEnclosingTypeChain(IType type, String typeName) { IType enclosing = type.getDeclaringType(); while (enclosing != null) { if (enclosing.getElementName().equals(typeName)) return true; enclosing = enclosing.getDeclaringType(); } return false; }
private boolean processCompilerError(RefactoringStatus result, ASTNode node) { Message[] messages = ASTNodes.getMessages(node, ASTNodes.INCLUDE_ALL_PARENTS); if (messages.length == 0) return false; result.addFatalError( Messages.format( "Compiler errors with the class to be refactored", new String[] {targetClass.getElementName(), messages[0].getMessage()})); return true; }
private void createSymbol(IType primaryType) { final IBeanInstanceSymbol bean = SymbolFactory.eINSTANCE.createIBeanInstanceSymbol(); bean.setName(getBeanName(primaryType.getElementName())); IJavaTypeDescriptor2 beanJavaTypeDescriptor = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2(); beanJavaTypeDescriptor.setType(primaryType); bean.setJavaTypeDescriptor(beanJavaTypeDescriptor); symbols.add(bean); }
public UpdateRetentionAnnotationValueMarkerResolution(IType type) { super(type.getCompilationUnit()); this.type = type; label = NLS.bind( JaxrsQuickFixMessages.UPDATE_RETENTION_ANNOTATION_VALUE_MARKER_RESOLUTION_TITLE, type.getElementName()); init(); }
/** * Searches for the method with the given binary name. * * @param name binary method name * @param signature binary method signature * @return method or <code>null</code> */ public IMethod findMethod(String name, String signature) { if ("<init>".equals(name)) { // $NON-NLS-1$ name = type.getElementName(); } final String paramCountKey = createParamCountKey(name, signature); if (ambiguous.contains(paramCountKey)) { return indexParamSignature.get(createParamSignatureKey(name, signature)); } else { return indexParamCount.get(paramCountKey); } }
public static IType[] findTypes(IType[] types, String[] namesOfTypesToPullUp) { List found = new ArrayList(types.length); for (int i = 0; i < types.length; i++) { IType type = types[i]; for (int j = 0; j < namesOfTypesToPullUp.length; j++) { String name = namesOfTypesToPullUp[j]; if (type.getElementName().equals(name)) found.add(type); } } return (IType[]) found.toArray(new IType[found.size()]); }
private static void checkTypeInType(IType destinationType, RefactoringStatus result, IType type) throws JavaModelException { String typeName = type.getElementName(); IType destinationTypeType = destinationType.getType(typeName); if (destinationTypeType.exists()) { String message = Messages.format( RefactoringCoreMessages.MemberCheckUtil_type_name_conflict0, new String[] { BasicElementLabels.getJavaElementName(typeName), getQualifiedLabel(destinationType) }); RefactoringStatusContext context = JavaStatusContext.create( destinationType.getCompilationUnit(), destinationTypeType.getNameRange()); result.addError(message, context); } else { // need to check the hierarchy of enclosing and enclosed types if (destinationType.getElementName().equals(typeName)) { String message = Messages.format( RefactoringCoreMessages.MemberCheckUtil_type_name_conflict1, getQualifiedLabel(type)); RefactoringStatusContext context = JavaStatusContext.create( destinationType.getCompilationUnit(), destinationType.getNameRange()); result.addError(message, context); } if (typeNameExistsInEnclosingTypeChain(destinationType, typeName)) { String message = Messages.format( RefactoringCoreMessages.MemberCheckUtil_type_name_conflict2, getQualifiedLabel(type)); RefactoringStatusContext context = JavaStatusContext.create( destinationType.getCompilationUnit(), destinationType.getNameRange()); result.addError(message, context); } checkHierarchyOfEnclosedTypes(destinationType, result, type); } }
private boolean hasMember(IType type, String name) { boolean result = false; try { for (IMethod method : type.getMethods()) { result |= name.equals(method.getElementName()); } } catch (JavaModelException jamox) { // defensive: assume the method is there, try another combination result = true; trace(jamox, type.getElementName()); } return result; }
/** @see IJavaElementRequestor */ public void acceptType(IType type) { try { if (this.unitToSkip != null && this.unitToSkip.equals(type.getCompilationUnit())) { return; } char[] packageName = type.getPackageFragment().getElementName().toCharArray(); boolean isBinary = type instanceof BinaryType; // determine associated access restriction AccessRestriction accessRestriction = null; if (this.checkAccessRestrictions && (isBinary || !type.getJavaProject().equals(this.project))) { PackageFragmentRoot root = (PackageFragmentRoot) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT); ClasspathEntry entry = (ClasspathEntry) this.nameLookup.rootToResolvedEntries.get(root); if (entry != null) { // reverse map always contains resolved CP entry AccessRuleSet accessRuleSet = entry.getAccessRuleSet(); if (accessRuleSet != null) { // TODO (philippe) improve char[] <-> String conversions to avoid performing them on the // fly char[][] packageChars = CharOperation.splitOn('.', packageName); char[] fileWithoutExtension = type.getElementName().toCharArray(); accessRestriction = accessRuleSet.getViolatedRestriction( CharOperation.concatWith(packageChars, fileWithoutExtension, '/')); } } } this.requestor.acceptType( packageName, type.getElementName().toCharArray(), null, type.getFlags(), accessRestriction); } catch (JavaModelException jme) { // ignore } }
private void printFileInternals(ICompilationUnit unit, StringBuilder sb) throws JavaModelException { IType[] allTypes = unit.getAllTypes(); if (allTypes.length > 0) { sb.append("<TYPES>"); for (IType type : allTypes) { sb.append("<TYPE NAME=\"" + type.getElementName() + "\">"); printSuperclassAndInterfaces(type, sb); printMethods(type, sb); sb.append("</TYPE>"); } sb.append("</TYPES>"); } }
/** * Runs the stub generation on the specified class file. * * @param file the class file * @param parent the parent store * @param monitor the progress monitor to use * @throws CoreException if an error occurs */ protected void run(final IClassFile file, final IFileStore parent, final IProgressMonitor monitor) throws CoreException { try { monitor.beginTask(RefactoringCoreMessages.StubCreationOperation_creating_type_stubs, 2); SubProgressMonitor subProgressMonitor = new SubProgressMonitor(monitor, 1); final IType type = file.getType(); if (type.isAnonymous() || type.isLocal() || type.isMember()) return; String source = new StubCreator(fStubInvisible).createStub(type, subProgressMonitor); createCompilationUnit( parent, type.getElementName() + JavaModelUtil.DEFAULT_CU_SUFFIX, source, monitor); } finally { monitor.done(); } }
private void createModel() { // // Initialize m_classes // Set<String> packageSet = Sets.newHashSet(); List<IType> types = Utils.findTypes(Utils.getSelectedJavaElements(), Utils.CONVERSION_FILTER); for (IType type : types) { String packageName = type.getPackageFragment().getElementName(); String className = type.getElementName(); if (className != null) { XmlClass c = new XmlClass(packageName + "." + className, false /* don't resolve */); p("Adding class " + c); m_classes.add(c); packageSet.add(packageName); } else { p("Adding type " + type); m_classes.add(new XmlClass(type.getFullyQualifiedName(), false /* don't resolve */)); packageSet.add(packageName); } } // for (JavaElement element : m_selectedElements) { // if (element.getClassName() != null) { // XmlClass c = new XmlClass(element.getPackageName() + "." + element.getClassName(), // false /* don't resolve */); // p("Adding class " + c); // m_classes.add(c); // packageSet.add(element.getPackageName()); // } else { // for (IType type : types) { // p("Adding type " + type); // m_classes.add(new XmlClass(type.getFullyQualifiedName(), false /* don't resolve // */)); // packageSet.add(type.getPackageFragment().getElementName()); // } // } // } // // Initialize m_packages // for (String p : packageSet) { XmlPackage pkg = new XmlPackage(); pkg.setName(p); p("Adding package " + p); m_packages.add(pkg); } m_xmlSuite = createXmlSuite(); }
public void build(boolean computeSubtypes) { JavaModelManager manager = JavaModelManager.getJavaModelManager(); try { // optimize access to zip files while building hierarchy manager.cacheZipFiles(this); if (computeSubtypes) { // Note by construction there always is a focus type here IType focusType = getType(); boolean focusIsObject = focusType.getElementName().equals(new String(IIndexConstants.OBJECT)); int amountOfWorkForSubtypes = focusIsObject ? 5 : 80; // percentage of work needed to get possible subtypes IProgressMonitor possibleSubtypesMonitor = this.hierarchy.progressMonitor == null ? null : new SubProgressMonitor(this.hierarchy.progressMonitor, amountOfWorkForSubtypes); HashSet localTypes = new HashSet( 10); // contains the paths that have potential subtypes that are local/anonymous // types String[] allPossibleSubtypes; if (((Member) focusType).getOuterMostLocalContext() == null) { // top level or member type allPossibleSubtypes = determinePossibleSubTypes(localTypes, possibleSubtypesMonitor); } else { // local or anonymous type allPossibleSubtypes = CharOperation.NO_STRINGS; } if (allPossibleSubtypes != null) { IProgressMonitor buildMonitor = this.hierarchy.progressMonitor == null ? null : new SubProgressMonitor( this.hierarchy.progressMonitor, 100 - amountOfWorkForSubtypes); this.hierarchy.initialize(allPossibleSubtypes.length); buildFromPotentialSubtypes(allPossibleSubtypes, localTypes, buildMonitor); } } else { this.hierarchy.initialize(1); buildSupertypes(); } } finally { manager.flushZipFiles(this); } }
/** * Runs the stub generation on the specified class file. * * @param file the class file * @param parent the parent store * @param monitor the progress monitor to use * @throws CoreException if an error occurs */ @Override protected void run(final IClassFile file, final IFileStore parent, final IProgressMonitor monitor) throws CoreException { try { monitor.beginTask(getOperationLabel(), 2); final IType type = file.getType(); if (type.isAnonymous() || type.isLocal() || type.isMember()) return; final String source = file.getSource(); createCompilationUnit( parent, type.getElementName() + JavaModelUtil.DEFAULT_CU_SUFFIX, source != null ? source : "", monitor); //$NON-NLS-1$ } finally { monitor.done(); } }
public IType getTypeForName(String typeName) throws JavaModelException { // long a = System.currentTimeMillis(); IType type; if ("void".equals(typeName) || (typeName != null && typeName.length() == 1)) { // ignore primitives type = null; } else { synchronized (_nextTypeCache) { type = _nextTypeCache.get(typeName); } if (type == null) { // long t = System.currentTimeMillis(); // MS: This call right here is the DEVIL. This is BY FAR where the // majority of time is spent during component validation. It's also // unfortunately completely necessary, but caching should focus on // this in the future. // String resolvedNextTypeName = JavaModelUtil.getResolvedTypeName(typeName, _type); type = resolveType(typeName, _type); if (type == null) { // We are going to hit KVCProtectedAccessor a LOT, and in most cases, it's just not // going to exist, so let's save us all some trouble and skip it ... if (!"QKeyValueCodingProtectedAccessor;".equals(typeName)) { System.out.println( "TypeCacheEntry.getTypeForName: Failed to resolve type name " + typeName + " in component " + _type.getElementName()); } else if (BindingReflectionUtils.isPrimitive(typeName)) { // ignore primitives if we get this far } } else { synchronized (_nextTypeCache) { _nextTypeCache.put(typeName, type); } } } // System.out.println("TypeCacheEntry.getTypeForName: " + typeName + " => " + // (System.currentTimeMillis() - t) + " => " + type); } // if (System.currentTimeMillis() -a > 0) { // System.out.println("TypeCache.TypeCacheEntry.getTypeForName: " + type.getElementName() + " // " + (System.currentTimeMillis() - a)); // } return type; }
public static IType[] getMemberTypes(IType type, String[] names) { if (names == null) return new IType[0]; Set memberTypes = new HashSet(); for (int i = 0; i < names.length; i++) { IType memberType; if (names[i].indexOf('.') != -1) { String[] path = names[i].split("\\."); memberType = type.getType(path[0]); for (int j = 1; j < path.length; j++) { memberType = memberType.getType(path[j]); } } else memberType = type.getType(names[i]); assertTrue( "member type " + memberType.getElementName() + " does not exist", memberType.exists()); memberTypes.add(memberType); } return (IType[]) memberTypes.toArray(new IType[memberTypes.size()]); }
protected ILaunchConfiguration createConfiguration(IType type) { ILaunchConfiguration config = null; ILaunchConfigurationWorkingCopy wc = null; try { ILaunchConfigurationType configType = getAJConfigurationType(); wc = configType.newInstance( null, getLaunchManager().generateLaunchConfigurationName(type.getElementName())); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, type.getJavaProject().getElementName()); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, type.getFullyQualifiedName()); config = wc.doSave(); } catch (CoreException exception) { reportErorr(exception); } return config; }
/** @see net.sf.commonclipse.Generator#createMethod(org.eclipse.jdt.core.IType) */ @Override protected String createMethod(IType type) throws JavaModelException { StringBuffer buffer = new StringBuffer(); buffer.append(getJavadoc()); String className = type.getElementName(); if (CCPluginPreferences.getPreferences().addOverrideAnnotation()) { buffer.append("@Override\n"); // $NON-NLS-1$ } buffer.append("public boolean equals("); // $NON-NLS-1$ if (CCPluginPreferences.getPreferences().useFinalParameters()) { buffer.append("final "); // $NON-NLS-1$ } buffer.append("Object object) {\n"); // $NON-NLS-1$ if (CCPluginPreferences.getPreferences().addInstanceCheckToEquals()) { buffer.append("if (object == this) {\nreturn true;\n}\n"); // $NON-NLS-1$ } buffer.append("if ( !(object instanceof "); // $NON-NLS-1$ buffer.append(className); buffer.append(") ) {\nreturn false;\n}\n"); // $NON-NLS-1$ buffer.append(className); buffer.append(" rhs = ("); // $NON-NLS-1$ buffer.append(className); buffer.append(") object;\nreturn new EqualsBuilder()\n"); // $NON-NLS-1$ if (CCPluginPreferences.getPreferences().appendSuperToEquals()) { buffer.append(".appendSuper(super.equals(object))\n"); // $NON-NLS-1$ } buffer.append(buildAppenderList(type)); buffer.append(".isEquals();\n}\n"); // $NON-NLS-1$ return buffer.toString(); }
/** Renames the main type in <code>cu</code>. */ private void updateTypeName( ICompilationUnit cu, CompilationUnit astCU, String oldName, String newName, ASTRewrite rewriter) throws JavaModelException { if (newName != null) { String oldTypeName = Util.getNameWithoutJavaLikeExtension(oldName); String newTypeName = Util.getNameWithoutJavaLikeExtension(newName); AST ast = astCU.getAST(); // update main type name IType[] types = cu.getTypes(); for (int i = 0, max = types.length; i < max; i++) { IType currentType = types[i]; if (currentType.getElementName().equals(oldTypeName)) { AbstractTypeDeclaration typeNode = (AbstractTypeDeclaration) ((JavaElement) currentType).findNode(astCU); if (typeNode != null) { // rename type rewriter.replace(typeNode.getName(), ast.newSimpleName(newTypeName), null); // rename constructors Iterator bodyDeclarations = typeNode.bodyDeclarations().iterator(); while (bodyDeclarations.hasNext()) { Object bodyDeclaration = bodyDeclarations.next(); if (bodyDeclaration instanceof MethodDeclaration) { MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration; if (methodDeclaration.isConstructor()) { SimpleName methodName = methodDeclaration.getName(); if (methodName.getIdentifier().equals(oldTypeName)) { rewriter.replace(methodName, ast.newSimpleName(newTypeName), null); } } } } } } } } }
/** Launch a compilation unit (a source file) based test. */ public static void launchCompilationUnitConfiguration( IJavaProject ijp, ICompilationUnit icu, String mode) { IType[] types = null; try { types = icu.getTypes(); } catch (JavaModelException jme) { TestNGPlugin.log( new Status( IStatus.ERROR, TestNGPlugin.PLUGIN_ID, TestNGPluginConstants.LAUNCH_ERROR, "No types in compilation unit " + icu.getElementName(), jme)); } if (null == types) return; IType mainType = icu.findPrimaryType(); final String confName = mainType != null ? mainType.getElementName() : icu.getElementName(); launchTypeBasedConfiguration(ijp, confName, types, mode); }
private void process() { try { IPreferenceStore preferenceStore = Activator.getDefault().getPreferenceStore(); String basepackage = preferenceStore.getString(JsfcaPerferenceConstants.PROP_KEY_BASE_PACKAGE); String regEx = preferenceStore.getString(JsfcaPerferenceConstants.PROP_KEY_FILE_PATTERN); if (basepackage == null || basepackage.isEmpty()) { return; } if (regEx == null || regEx.isEmpty()) { return; } Pattern classPattern = Pattern.compile(regEx); IPackageFragment[] packageFragments = javaProject.getPackageFragments(); for (IPackageFragment packageFragment : packageFragments) { if (packageFragment.getElementName().startsWith(basepackage.toLowerCase())) { if (packageFragment.containsJavaResources()) { ICompilationUnit[] compilationUnits = packageFragment.getCompilationUnits(); for (ICompilationUnit compUnit : compilationUnits) { IType primaryType = compUnit.findPrimaryType(); if (primaryType != null && classPattern.matcher(primaryType.getElementName()).matches()) { createSymbol(primaryType); } } } } } } catch (JavaModelException e) { e.printStackTrace(); } }
protected void browseForAccessorClass() { IProgressService service = PlatformUI.getWorkbench().getProgressService(); IPackageFragmentRoot root = fAccessorPackage.getSelectedFragmentRoot(); IJavaSearchScope scope = root != null ? SearchEngine.createJavaSearchScope(new IJavaElement[] {root}) : SearchEngine.createWorkspaceScope(); FilteredTypesSelectionDialog dialog = new FilteredTypesSelectionDialog( getShell(), false, service, scope, IJavaSearchConstants.CLASS); dialog.setTitle(NLSUIMessages.NLSAccessorConfigurationDialog_Accessor_Selection); dialog.setMessage(NLSUIMessages.NLSAccessorConfigurationDialog_Choose_the_accessor_file); dialog.setInitialPattern("*Messages"); // $NON-NLS-1$ if (dialog.open() == Window.OK) { IType selectedType = (IType) dialog.getFirstResult(); if (selectedType != null) { fAccessorClassName.setText(selectedType.getElementName()); fAccessorPackage.setSelected(selectedType.getPackageFragment()); } } }
/** * Constructs a compilation unit relative name for the supplied type. * * <p>If the type is imported, in java.lang, or in the same package as the source file, then the * type name returned is unqualified, otherwise the name returned is the fully qualified type * name. * * @param src The compilation unit. * @param type The type. * @return The relative type name. */ public static String getCompilationUnitRelativeTypeName(ICompilationUnit src, IType type) throws Exception { String typeName = type.getFullyQualifiedName().replace('$', '.'); if (JavaUtils.containsImport(src, type)) { typeName = type.getElementName(); int parentType = type.getParent().getElementType(); if (parentType == IJavaElement.TYPE) { typeName = type.getParent().getElementName() + '.' + typeName; } else if (parentType == IJavaElement.CLASS_FILE) { String parentName = type.getParent().getElementName(); int index = parentName.indexOf('$'); if (index != -1) { parentName = parentName.substring(0, index); typeName = parentName + '.' + typeName; } } } else { typeName = type.getFullyQualifiedName().replace('$', '.'); } return typeName; }
/** * Find the set of candidate subtypes of a given type. * * <p>The requestor is notified of super type references (with actual path of its occurrence) for * all types which are potentially involved inside a particular hierarchy. The match locator is * not used here to narrow down the results, the type hierarchy resolver is rather used to compute * the whole hierarchy at once. * * @param type * @param scope * @param binariesFromIndexMatches * @param pathRequestor * @param waitingPolicy * @param progressMonitor */ public static void searchAllPossibleSubTypes( IType type, IJavaSearchScope scope, final Map binariesFromIndexMatches, final IPathRequestor pathRequestor, int waitingPolicy, // WaitUntilReadyToSearch | ForceImmediateSearch | CancelIfNotReadyToSearch final IProgressMonitor progressMonitor) { /* embed constructs inside arrays so as to pass them to (inner) collector */ final Queue queue = new Queue(); final HashtableOfObject foundSuperNames = new HashtableOfObject(5); IndexManager indexManager = JavaModelManager.getIndexManager(); /* use a special collector to collect paths and queue new subtype names */ IndexQueryRequestor searchRequestor = new IndexQueryRequestor() { public boolean acceptIndexMatch( String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) { SuperTypeReferencePattern record = (SuperTypeReferencePattern) indexRecord; boolean isLocalOrAnonymous = record.enclosingTypeName == IIndexConstants.ONE_ZERO; pathRequestor.acceptPath(documentPath, isLocalOrAnonymous); char[] typeName = record.simpleName; if (documentPath.toLowerCase().endsWith(SUFFIX_STRING_class)) { int suffix = documentPath.length() - SUFFIX_STRING_class.length(); HierarchyBinaryType binaryType = (HierarchyBinaryType) binariesFromIndexMatches.get(documentPath); if (binaryType == null) { char[] enclosingTypeName = record.enclosingTypeName; if (isLocalOrAnonymous) { int lastSlash = documentPath.lastIndexOf('/'); int lastDollar = documentPath.lastIndexOf('$'); if (lastDollar == -1) { // malformed local or anonymous type: it doesn't contain a $ in its name // treat it as a top level type enclosingTypeName = null; typeName = documentPath.substring(lastSlash + 1, suffix).toCharArray(); } else { enclosingTypeName = documentPath.substring(lastSlash + 1, lastDollar).toCharArray(); typeName = documentPath.substring(lastDollar + 1, suffix).toCharArray(); } } binaryType = new HierarchyBinaryType( record.modifiers, record.pkgName, typeName, enclosingTypeName, record.typeParameterSignatures, record.classOrInterface); binariesFromIndexMatches.put(documentPath, binaryType); } binaryType.recordSuperType( record.superSimpleName, record.superQualification, record.superClassOrInterface); } if (!isLocalOrAnonymous // local or anonymous types cannot have subtypes outside the cu // that define them && !foundSuperNames.containsKey(typeName)) { foundSuperNames.put(typeName, typeName); queue.add(typeName); } return true; } }; int superRefKind; try { superRefKind = type.isClass() ? SuperTypeReferencePattern.ONLY_SUPER_CLASSES : SuperTypeReferencePattern.ALL_SUPER_TYPES; } catch (JavaModelException e) { superRefKind = SuperTypeReferencePattern.ALL_SUPER_TYPES; } SuperTypeReferencePattern pattern = new SuperTypeReferencePattern( null, null, superRefKind, SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE); MatchLocator.setFocus(pattern, type); SubTypeSearchJob job = new SubTypeSearchJob( pattern, new JavaSearchParticipant(), // java search only scope, searchRequestor); int ticks = 0; queue.add(type.getElementName().toCharArray()); try { while (queue.start <= queue.end) { if (progressMonitor != null && progressMonitor.isCanceled()) return; // all subclasses of OBJECT are actually all types char[] currentTypeName = queue.retrieve(); if (CharOperation.equals(currentTypeName, IIndexConstants.OBJECT)) currentTypeName = null; // search all index references to a given supertype pattern.superSimpleName = currentTypeName; indexManager.performConcurrentJob( job, waitingPolicy, progressMonitor == null ? null : new NullProgressMonitor() { // don't report progress since this is too costly for deep hierarchies (see // https://bugs.eclipse.org/bugs/show_bug.cgi?id=34078 ) // just handle isCanceled() (see // https://bugs.eclipse.org/bugs/show_bug.cgi?id=179511 ) public void setCanceled(boolean value) { progressMonitor.setCanceled(value); } public boolean isCanceled() { return progressMonitor.isCanceled(); } // and handle subTask(...) (see // https://bugs.eclipse.org/bugs/show_bug.cgi?id=34078 ) public void subTask(String name) { progressMonitor.subTask(name); } }); if (progressMonitor != null && ++ticks <= MAXTICKS) progressMonitor.worked(1); // in case, we search all subtypes, no need to search further if (currentTypeName == null) break; } } finally { job.finished(); } }