### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core
Index: model/org/eclipse/jdt/internal/core/hierarchy/IndexBasedHierarchyBuilder.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/hierarchy/IndexBasedHierarchyBuilder.java,v
retrieving revision 1.97
diff -u -r1.97 IndexBasedHierarchyBuilder.java
--- model/org/eclipse/jdt/internal/core/hierarchy/IndexBasedHierarchyBuilder.java	29 Mar 2006 03:14:01 -0000	1.97
+++ model/org/eclipse/jdt/internal/core/hierarchy/IndexBasedHierarchyBuilder.java	16 Jun 2006 15:29:12 -0000
@@ -25,6 +25,7 @@
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
 import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
+import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;
 import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
 import org.eclipse.jdt.internal.core.*;
 import org.eclipse.jdt.internal.core.search.IndexQueryRequestor;
@@ -137,13 +138,40 @@
 	}
 }
 private void buildForProject(JavaProject project, ArrayList potentialSubtypes, org.eclipse.jdt.core.ICompilationUnit[] workingCopies, HashSet localTypes, IProgressMonitor monitor) throws JavaModelException {
-	// copy vectors into arrays
-	int openablesLength = potentialSubtypes.size();
-	Openable[] openables = new Openable[openablesLength];
-	potentialSubtypes.toArray(openables);
-
 	// 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);
+		}
+		Util.sort(openables, new Util.Comparer() {
+			public int compare(Object a, Object b) {
+				int aIndex = indexes.get(a);
+				int bIndex = indexes.get(b);
+				if (aIndex < bIndex)
+					return -1;
+				else if (aIndex > bIndex)
+					return 1;
+				return ((Openable) b).getElementName().compareTo(((Openable) a).getElementName());
+			}
+		});
+		
 		IType focusType = this.getType();
 		boolean inProjectOfFocusType = focusType != null && focusType.getJavaProject().equals(project);
 		org.eclipse.jdt.core.ICompilationUnit[] unitsToLookInside = null;
@@ -240,17 +268,7 @@
 		length++;
 	}
 	
-	// sort by projects
-	/*
-	 * NOTE: To workaround pb with hierarchy resolver that requests top  
-	 * level types in the process of caching an enclosing type, this needs to
-	 * be sorted in reverse alphabetical order so that top level types are cached
-	 * before their inner types.
-	 */
-	org.eclipse.jdt.internal.core.util.Util.sortReverseOrder(allPotentialSubTypes);
-	
 	ArrayList potentialSubtypes = new ArrayList();
-
 	try {
 		// create element infos for subtypes
 		HandleFactory factory = new HandleFactory();
Index: model/org/eclipse/jdt/internal/core/util/Util.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/Util.java,v
retrieving revision 1.96
diff -u -r1.96 Util.java
--- model/org/eclipse/jdt/internal/core/util/Util.java	9 Jun 2006 11:25:03 -0000	1.96
+++ model/org/eclipse/jdt/internal/core/util/Util.java	16 Jun 2006 15:29:13 -0000
@@ -1616,39 +1616,6 @@
 	}
 
 	/**
-	 * Sort the objects in the given collection using the given sort order.
-	 */
-	private static void quickSort(Object[] sortedCollection, int left, int right, int[] sortOrder) {
-		int original_left = left;
-		int original_right = right;
-		int mid = sortOrder[ (left + right) / 2];
-		do {
-			while (sortOrder[left] < mid) {
-				left++;
-			}
-			while (mid < sortOrder[right]) {
-				right--;
-			}
-			if (left <= right) {
-				Object tmp = sortedCollection[left];
-				sortedCollection[left] = sortedCollection[right];
-				sortedCollection[right] = tmp;
-				int tmp2 = sortOrder[left];
-				sortOrder[left] = sortOrder[right];
-				sortOrder[right] = tmp2;
-				left++;
-				right--;
-			}
-		} while (left <= right);
-		if (original_left < right) {
-			quickSort(sortedCollection, original_left, right, sortOrder);
-		}
-		if (left < original_right) {
-			quickSort(sortedCollection, left, original_right, sortOrder);
-		}
-	}
-
-	/**
 	 * Sort the strings in the given collection.
 	 */
 	private static void quickSort(String[] sortedCollection, int left, int right) {
@@ -1679,35 +1646,6 @@
 	}
 
 	/**
-	 * Sort the strings in the given collection in reverse alphabetical order.
-	 */
-	private static void quickSortReverse(String[] sortedCollection, int left, int right) {
-		int original_left = left;
-		int original_right = right;
-		String mid = sortedCollection[ (left + right) / 2];
-		do {
-			while (sortedCollection[left].compareTo(mid) > 0) {
-				left++;
-			}
-			while (mid.compareTo(sortedCollection[right]) > 0) {
-				right--;
-			}
-			if (left <= right) {
-				String tmp = sortedCollection[left];
-				sortedCollection[left] = sortedCollection[right];
-				sortedCollection[right] = tmp;
-				left++;
-				right--;
-			}
-		} while (left <= right);
-		if (original_left < right) {
-			quickSortReverse(sortedCollection, original_left, right);
-		}
-		if (left < original_right) {
-			quickSortReverse(sortedCollection, left, original_right);
-		}
-	}
-	/**
 	 * Reads in a string from the specified data input stream. The 
 	 * string has been encoded using a modified UTF-8 format. 
 	 * <p>
@@ -1923,14 +1861,6 @@
 	}
 
 	/**
-	 * Sorts an array of objects in place, using the sort order given for each item.
-	 */
-	public static void sort(Object[] objects, int[] sortOrder) {
-		if (objects.length > 1)
-			quickSort(objects, 0, objects.length - 1, sortOrder);
-	}
-
-	/**
 	 * Sorts an array of strings in place using quicksort.
 	 */
 	public static void sort(String[] strings) {
@@ -1991,15 +1921,6 @@
 		return copy;
 	}
 
-	/**
-	 * Sorts an array of strings in place using quicksort
-	 * in reverse alphabetical order.
-	 */
-	public static void sortReverseOrder(String[] strings) {
-		if (strings.length > 1)
-			quickSortReverse(strings, 0, strings.length - 1);
-	}
-	
 	/*
 	 * Returns whether the given compound name starts with the given prefix.
 	 * Returns true if the n first elements of the prefix are equals and the last element of the