public static void collectCompilationUnits(
List<ICompilationUnit> result, IPackageFragmentRoot root) throws JavaModelException {
IJavaElement[] elements = root.getChildren();
for (int j = 0; j < elements.length; ++j) {
IPackageFragment p = (IPackageFragment) elements[j];
result.addAll(Arrays.asList(p.getCompilationUnits()));
}
}
/** Configure this type hierarchy based on the given potential subtypes. */
private void buildFromPotentialSubtypes(
String[] allPotentialSubTypes, HashSet localTypes, IProgressMonitor monitor) {
IType focusType = getType();
// substitute compilation units with working copies
HashMap wcPaths = new HashMap(); // a map from path to working copies
int wcLength;
org.eclipse.jdt.core.ICompilationUnit[] workingCopies = this.hierarchy.workingCopies;
if (workingCopies != null && (wcLength = workingCopies.length) > 0) {
String[] newPaths = new String[wcLength];
for (int i = 0; i < wcLength; i++) {
org.eclipse.jdt.core.ICompilationUnit workingCopy = workingCopies[i];
String path = workingCopy.getPath().toString();
wcPaths.put(path, workingCopy);
newPaths[i] = path;
}
int potentialSubtypesLength = allPotentialSubTypes.length;
System.arraycopy(
allPotentialSubTypes,
0,
allPotentialSubTypes = new String[potentialSubtypesLength + wcLength],
0,
potentialSubtypesLength);
System.arraycopy(newPaths, 0, allPotentialSubTypes, potentialSubtypesLength, wcLength);
}
int length = allPotentialSubTypes.length;
// inject the compilation unit of the focus type (so that types in
// this cu have special visibility permission (this is also usefull
// when the cu is a working copy)
Openable focusCU = (Openable) focusType.getCompilationUnit();
String focusPath = null;
if (focusCU != null) {
focusPath = focusCU.getPath().toString();
if (length > 0) {
System.arraycopy(
allPotentialSubTypes, 0, allPotentialSubTypes = new String[length + 1], 0, length);
allPotentialSubTypes[length] = focusPath;
} else {
allPotentialSubTypes = new String[] {focusPath};
}
length++;
}
/*
* Sort in alphabetical order so that potential subtypes are grouped per project
*/
Arrays.sort(allPotentialSubTypes);
ArrayList potentialSubtypes = new ArrayList();
try {
// create element infos for subtypes
HandleFactory factory = new HandleFactory();
IJavaProject currentProject = null;
if (monitor != null)
monitor.beginTask(
"", length * 2 /* 1 for build binding, 1 for connect hierarchy*/); // $NON-NLS-1$
for (int i = 0; i < length; i++) {
try {
String resourcePath = allPotentialSubTypes[i];
// skip duplicate paths (e.g. if focus path was injected when it was already a potential
// subtype)
if (i > 0 && resourcePath.equals(allPotentialSubTypes[i - 1])) continue;
Openable handle;
org.eclipse.jdt.core.ICompilationUnit workingCopy =
(org.eclipse.jdt.core.ICompilationUnit) wcPaths.get(resourcePath);
if (workingCopy != null) {
handle = (Openable) workingCopy;
} else {
handle =
resourcePath.equals(focusPath)
? focusCU
: factory.createOpenable(resourcePath, this.scope);
if (handle == null) continue; // match is outside classpath
}
IJavaProject project = handle.getJavaProject();
if (currentProject == null) {
currentProject = project;
potentialSubtypes = new ArrayList(5);
} else if (!currentProject.equals(project)) {
// build current project
buildForProject(
(JavaProject) currentProject,
potentialSubtypes,
workingCopies,
localTypes,
monitor);
currentProject = project;
potentialSubtypes = new ArrayList(5);
}
potentialSubtypes.add(handle);
} catch (JavaModelException e) {
continue;
}
}
// build last project
try {
if (currentProject == null) {
// case of no potential subtypes
currentProject = focusType.getJavaProject();
if (focusType.isBinary()) {
potentialSubtypes.add(focusType.getClassFile());
} else {
potentialSubtypes.add(focusType.getCompilationUnit());
}
}
buildForProject(
(JavaProject) currentProject, potentialSubtypes, workingCopies, localTypes, monitor);
} catch (JavaModelException e) {
// ignore
}
// Compute hierarchy of focus type if not already done (case of a type with potential subtypes
// that are not real subtypes)
if (!this.hierarchy.contains(focusType)) {
try {
currentProject = focusType.getJavaProject();
potentialSubtypes = new ArrayList();
if (focusType.isBinary()) {
potentialSubtypes.add(focusType.getClassFile());
} else {
potentialSubtypes.add(focusType.getCompilationUnit());
}
buildForProject(
(JavaProject) currentProject, potentialSubtypes, workingCopies, localTypes, monitor);
} catch (JavaModelException e) {
// ignore
}
}
// Add focus if not already in (case of a type with no explicit super type)
if (!this.hierarchy.contains(focusType)) {
this.hierarchy.addRootClass(focusType);
}
} finally {
if (monitor != null) monitor.done();
}
}
private void buildForProject(
JavaProject project,
ArrayList potentialSubtypes,
org.eclipse.jdt.core.ICompilationUnit[] workingCopies,
HashSet localTypes,
IProgressMonitor monitor)
throws JavaModelException {
// resolve
int openablesLength = potentialSubtypes.size();
if (openablesLength > 0) {
// copy vectors into arrays
Openable[] openables = new Openable[openablesLength];
potentialSubtypes.toArray(openables);
// sort in the order of roots and in reverse alphabetical order for .class file
// since requesting top level types in the process of caching an enclosing type is
// not supported by the lookup environment
IPackageFragmentRoot[] roots = project.getPackageFragmentRoots();
int rootsLength = roots.length;
final HashtableOfObjectToInt indexes = new HashtableOfObjectToInt(openablesLength);
for (int i = 0; i < openablesLength; i++) {
IJavaElement root = openables[i].getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
int index;
for (index = 0; index < rootsLength; index++) {
if (roots[index].equals(root)) break;
}
indexes.put(openables[i], index);
}
Arrays.sort(
openables,
new Comparator() {
public int compare(Object a, Object b) {
int aIndex = indexes.get(a);
int bIndex = indexes.get(b);
if (aIndex != bIndex) return aIndex - bIndex;
return ((Openable) b).getElementName().compareTo(((Openable) a).getElementName());
}
});
IType focusType = getType();
boolean inProjectOfFocusType =
focusType != null && focusType.getJavaProject().equals(project);
org.eclipse.jdt.core.ICompilationUnit[] unitsToLookInside = null;
if (inProjectOfFocusType) {
org.eclipse.jdt.core.ICompilationUnit unitToLookInside = focusType.getCompilationUnit();
if (unitToLookInside != null) {
int wcLength = workingCopies == null ? 0 : workingCopies.length;
if (wcLength == 0) {
unitsToLookInside = new org.eclipse.jdt.core.ICompilationUnit[] {unitToLookInside};
} else {
unitsToLookInside = new org.eclipse.jdt.core.ICompilationUnit[wcLength + 1];
unitsToLookInside[0] = unitToLookInside;
System.arraycopy(workingCopies, 0, unitsToLookInside, 1, wcLength);
}
} else {
unitsToLookInside = workingCopies;
}
}
SearchableEnvironment searchableEnvironment =
project.newSearchableNameEnvironment(unitsToLookInside);
this.nameLookup = searchableEnvironment.nameLookup;
Map options = project.getOptions(true);
// disable task tags to speed up parsing
options.put(JavaCore.COMPILER_TASK_TAGS, ""); // $NON-NLS-1$
this.hierarchyResolver =
new HierarchyResolver(searchableEnvironment, options, this, new DefaultProblemFactory());
if (focusType != null) {
Member declaringMember = ((Member) focusType).getOuterMostLocalContext();
if (declaringMember == null) {
// top level or member type
if (!inProjectOfFocusType) {
char[] typeQualifiedName = focusType.getTypeQualifiedName('.').toCharArray();
String[] packageName = ((PackageFragment) focusType.getPackageFragment()).names;
if (searchableEnvironment.findType(typeQualifiedName, Util.toCharArrays(packageName))
== null) {
// focus type is not visible in this project: no need to go further
return;
}
}
} else {
// local or anonymous type
Openable openable;
if (declaringMember.isBinary()) {
openable = (Openable) declaringMember.getClassFile();
} else {
openable = (Openable) declaringMember.getCompilationUnit();
}
localTypes = new HashSet();
localTypes.add(openable.getPath().toString());
this.hierarchyResolver.resolve(new Openable[] {openable}, localTypes, monitor);
return;
}
}
this.hierarchyResolver.resolve(openables, localTypes, monitor);
}
}