### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core
Index: model/org/eclipse/jdt/internal/core/JavaProject.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java,v
retrieving revision 1.388
diff -u -r1.388 JavaProject.java
--- model/org/eclipse/jdt/internal/core/JavaProject.java	18 Apr 2007 14:30:40 -0000	1.388
+++ model/org/eclipse/jdt/internal/core/JavaProject.java	23 Apr 2007 20:59:54 -0000
@@ -66,6 +66,7 @@
 import org.eclipse.jdt.internal.compiler.util.ObjectVector;
 import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
 import org.eclipse.jdt.internal.core.JavaModelManager.PerProjectInfo;
+import org.eclipse.jdt.internal.core.JavaProjectElementInfo.ProjectCache;
 import org.eclipse.jdt.internal.core.builder.JavaBuilder;
 import org.eclipse.jdt.internal.core.eval.EvaluationContextWrapper;
 import org.eclipse.jdt.internal.core.util.MementoTokenizer;
@@ -1809,6 +1810,10 @@
 	public IProject getProject() {
 		return this.project;
 	}
+	
+	public ProjectCache getProjectCache() throws JavaModelException {
+		return ((JavaProjectElementInfo) getElementInfo()).getProjectCache(this);
+	}
 
 	/**
 	 * @see IJavaProject
Index: model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java,v
retrieving revision 1.46
diff -u -r1.46 JavaProjectElementInfo.java
--- model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java	23 Apr 2007 10:52:16 -0000	1.46
+++ model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java	23 Apr 2007 20:59:54 -0000
@@ -37,10 +37,10 @@
 	static final IPackageFragmentRoot[] NO_ROOTS = new IPackageFragmentRoot[0];
 
 	static class ProjectCache {
-		ProjectCache(IPackageFragmentRoot[] allPkgFragmentRootsCache, HashtableOfArrayToObject allPkgFragmentsCache, Map rootToResolvedEntries) {
+		ProjectCache(IPackageFragmentRoot[] allPkgFragmentRootsCache, Map rootToResolvedEntries, Map pkgFragmentsCaches) {
 			this.allPkgFragmentRootsCache = allPkgFragmentRootsCache;
-			this.allPkgFragmentsCache = allPkgFragmentsCache;
 			this.rootToResolvedEntries = rootToResolvedEntries;
+			this.pkgFragmentsCaches = pkgFragmentsCaches;
 		}
 		
 		/*
@@ -50,9 +50,16 @@
 		
 		/*
 		 * A cache of all package fragments in this project.
-		 * (a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name)
+		 * (an array of a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name))
 		 */
-		public HashtableOfArrayToObject allPkgFragmentsCache;
+		public HashtableOfArrayToObject[] allPkgFragmentsCaches;
+		
+		/*
+		 * A cache of package fragments for each package fragment root of this project
+		 * (a map from IPackageFragmentRoot to
+		 *  a map from String[] (the package name) to IPackageFragmentRoot[] (the package fragment roots that contain a package fragment with this name))
+		 */
+		public Map pkgFragmentsCaches;
 		
 		public Map rootToResolvedEntries;		
 	}
@@ -202,47 +209,21 @@
 				reverseMap.clear();
 			}
 			
-			HashMap otherRoots = JavaModelManager.getJavaModelManager().deltaState.otherRoots;
-			HashtableOfArrayToObject fragmentsCache = new HashtableOfArrayToObject();
-			for (int i = 0, length = roots.length; i < length; i++) {
+			HashMap rootInfos = JavaModelManager.getJavaModelManager().deltaState.roots;
+			HashMap pkgFragmentsCaches = new HashMap();
+			int length = roots.length;
+			for (int i = 0; i < length; i++) {
 				IPackageFragmentRoot root = roots[i];
-				IJavaElement[] frags = null;
-				try {
-					if (root.isArchive() 
-							&& !root.isOpen() 
-							&& otherRoots.get(((JarPackageFragmentRoot) root).jarPath) == null/*only if jar belongs to 1 project (https://bugs.eclipse.org/bugs/show_bug.cgi?id=161175)*/) {
-						JarPackageFragmentRootInfo info = new JarPackageFragmentRootInfo();
-						((JarPackageFragmentRoot) root).computeChildren(info, new HashMap());
-						frags = info.children;
-					} else 
-						frags = root.getChildren();
-				} catch (JavaModelException e) {
-					// root doesn't exist: ignore
-					continue;
-				}
-				for (int j = 0, length2 = frags.length; j < length2; j++) {
-					PackageFragment fragment= (PackageFragment) frags[j];
-					String[] pkgName = fragment.names;
-					Object existing = fragmentsCache.get(pkgName);
-					if (existing == null || existing == NO_ROOTS) {
-						fragmentsCache.put(pkgName, root);
-						// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
-						// are also in the map
-						addSuperPackageNames(pkgName, fragmentsCache);
-					} else {
-						if (existing instanceof PackageFragmentRoot) {
-							fragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
-						} else {
-							IPackageFragmentRoot[] entry= (IPackageFragmentRoot[]) existing;
-							IPackageFragmentRoot[] copy= new IPackageFragmentRoot[entry.length + 1];
-							System.arraycopy(entry, 0, copy, 0, entry.length);
-							copy[entry.length]= root;
-							fragmentsCache.put(pkgName, copy);
-						}
-					}
+				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInfo) rootInfos.get(root.getPath());
+				if (rootInfo == null || rootInfo.project.equals(project)) {
+					// compute fragment cache
+					HashtableOfArrayToObject fragmentsCache = new HashtableOfArrayToObject();
+					initializePackageNames(root, fragmentsCache);
+					pkgFragmentsCaches.put(root, fragmentsCache);
 				}
 			}
-			cache = new ProjectCache(roots, fragmentsCache, reverseMap);
+			
+			cache = new ProjectCache(roots, reverseMap, pkgFragmentsCaches);
 			this.projectCache = cache;
 		}
 		return cache;
@@ -258,6 +239,42 @@
 		}
 		return this.nonJavaResources;
 	}
+	
+	private void initializePackageNames(IPackageFragmentRoot root, HashtableOfArrayToObject fragmentsCache) {
+		IJavaElement[] frags = null;
+		try {
+			if (!root.isOpen()) {
+				PackageFragmentRootInfo info = root.isArchive() ? new JarPackageFragmentRootInfo() : new PackageFragmentRootInfo();
+				((PackageFragmentRoot) root).computeChildren(info, new HashMap());
+				frags = info.children;
+			} else 
+				frags = root.getChildren();
+		} catch (JavaModelException e) {
+			// root doesn't exist: ignore
+			return;
+		}
+		for (int j = 0, length2 = frags.length; j < length2; j++) {
+			PackageFragment fragment= (PackageFragment) frags[j];
+			String[] pkgName = fragment.names;
+			Object existing = fragmentsCache.get(pkgName);
+			if (existing == null || existing == NO_ROOTS) {
+				fragmentsCache.put(pkgName, root);
+				// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
+				// are also in the map
+				addSuperPackageNames(pkgName, fragmentsCache);
+			} else {
+				if (existing instanceof PackageFragmentRoot) {
+					fragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
+				} else {
+					IPackageFragmentRoot[] entry= (IPackageFragmentRoot[]) existing;
+					IPackageFragmentRoot[] copy= new IPackageFragmentRoot[entry.length + 1];
+					System.arraycopy(entry, 0, copy, 0, entry.length);
+					copy[entry.length]= root;
+					fragmentsCache.put(pkgName, copy);
+				}
+			}
+		}
+	}
 
 	/*
 	 * Returns whether the given path is a classpath entry or an output location.
@@ -284,7 +301,35 @@
 	 */
 	NameLookup newNameLookup(JavaProject project, ICompilationUnit[] workingCopies) {
 		ProjectCache cache = getProjectCache(project);
-		return new NameLookup(cache.allPkgFragmentRootsCache, cache.allPkgFragmentsCache, workingCopies, cache.rootToResolvedEntries);
+		HashtableOfArrayToObject[] allPkgFragmentsCaches = cache.allPkgFragmentsCaches;
+		if (allPkgFragmentsCaches == null) {
+			HashMap rootInfos = JavaModelManager.getJavaModelManager().deltaState.roots;
+			IPackageFragmentRoot[] roots = cache.allPkgFragmentRootsCache;
+			int length = roots.length;
+			allPkgFragmentsCaches = new HashtableOfArrayToObject[length];
+			for (int i = 0; i < length; i++) {
+				IPackageFragmentRoot root = roots[i];
+				DeltaProcessor.RootInfo rootInfo = (DeltaProcessor.RootInfo) rootInfos.get(root.getPath());
+				JavaProject rootProject = rootInfo == null ? project : rootInfo.project;
+				HashtableOfArrayToObject fragmentsCache;
+				if (rootProject.equals(project)) {
+					fragmentsCache = (HashtableOfArrayToObject) cache.pkgFragmentsCaches.get(root);
+				} else {
+					// retrieve fragment cache from root project
+					ProjectCache rootProjectCache;
+					try {
+						rootProjectCache = rootProject.getProjectCache();
+					} catch (JavaModelException e) {
+						// project doesn't exit
+						continue;
+					}
+					fragmentsCache = (HashtableOfArrayToObject) rootProjectCache.pkgFragmentsCaches.get(root);
+				}
+				allPkgFragmentsCaches[i] = fragmentsCache;
+			}
+			cache.allPkgFragmentsCaches = allPkgFragmentsCaches;
+		}
+		return new NameLookup(cache.allPkgFragmentRootsCache, cache.allPkgFragmentsCaches, workingCopies, cache.rootToResolvedEntries);
 	}
 	
 	/*
Index: model/org/eclipse/jdt/internal/core/NameLookup.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/NameLookup.java,v
retrieving revision 1.113
diff -u -r1.113 NameLookup.java
--- model/org/eclipse/jdt/internal/core/NameLookup.java	23 Apr 2007 10:52:16 -0000	1.113
+++ model/org/eclipse/jdt/internal/core/NameLookup.java	23 Apr 2007 20:59:55 -0000
@@ -123,7 +123,9 @@
 	 * Note if the list is of size 1, then the IPackageFragmentRoot object
 	 * replaces the array.
 	 */
-	protected HashtableOfArrayToObject packageFragments;
+	protected HashtableOfArrayToObject[] packageFragmentsCaches;
+	
+	protected HashtableOfArrayToObject workingCopyFragmentsCache;
 	
 	/**
 	 * Reverse map from root path to corresponding resolved CP entry
@@ -142,29 +144,24 @@
 
 	public NameLookup(
 			IPackageFragmentRoot[] packageFragmentRoots, 
-			HashtableOfArrayToObject packageFragments, 
+			HashtableOfArrayToObject[] packageFragmentsCaches, 
 			ICompilationUnit[] workingCopies, 
 			Map rootToResolvedEntries) {
 		long start = -1;
 		if (VERBOSE) {
 			Util.verbose(" BUILDING NameLoopkup");  //$NON-NLS-1$
 			Util.verbose(" -> pkg roots size: " + (packageFragmentRoots == null ? 0 : packageFragmentRoots.length));  //$NON-NLS-1$
-			Util.verbose(" -> pkgs size: " + (packageFragments == null ? 0 : packageFragments.size()));  //$NON-NLS-1$
+			//Util.verbose(" -> pkgs size: " + (packageFragments == null ? 0 : packageFragments.size()));  //$NON-NLS-1$
 			Util.verbose(" -> working copy size: " + (workingCopies == null ? 0 : workingCopies.length));  //$NON-NLS-1$
 			start = System.currentTimeMillis();
 		}
 		this.packageFragmentRoots = packageFragmentRoots;
-		if (workingCopies == null) {
-			this.packageFragments = packageFragments;
-		} else {
-			// clone tables as we're adding packages from working copies
-			try {
-				this.packageFragments = (HashtableOfArrayToObject) packageFragments.clone();
-			} catch (CloneNotSupportedException e1) {
-				// ignore (implementation of HashtableOfArrayToObject supports cloning)
-			}
+		this.packageFragmentsCaches = packageFragmentsCaches;
+		this.workingCopyFragmentsCache = new HashtableOfArrayToObject();
+		if (workingCopies != null) {
+			// add packages from working copies first
 			this.typesInWorkingCopies = new HashMap();
-			for (int i = 0, length = workingCopies.length; i < length; i++) {
+			for (int i = 0, length2 = workingCopies.length; i < length2; i++) {
 				ICompilationUnit workingCopy = workingCopies[i];
 				PackageFragment pkg = (PackageFragment) workingCopy.getParent();
 				HashMap typeMap = (HashMap) this.typesInWorkingCopies.get(pkg);
@@ -203,16 +200,16 @@
 				// add root of package fragment to cache
 				IPackageFragmentRoot root = (IPackageFragmentRoot) pkg.getParent();
 				String[] pkgName = pkg.names;
-				Object existing = this.packageFragments.get(pkgName);
+				Object existing = this.workingCopyFragmentsCache.get(pkgName);
 				if (existing == null || existing == JavaProjectElementInfo.NO_ROOTS) {
-					this.packageFragments.put(pkgName, root);
+					workingCopyFragmentsCache.put(pkgName, root);
 					// ensure super packages (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
 					// are also in the map
-					JavaProjectElementInfo.addSuperPackageNames(pkgName, this.packageFragments);
+					JavaProjectElementInfo.addSuperPackageNames(pkgName, this.workingCopyFragmentsCache);
 				} else {
 					if (existing instanceof PackageFragmentRoot) {
 						if (!existing.equals(root))
-							this.packageFragments.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
+							this.workingCopyFragmentsCache.put(pkgName, new IPackageFragmentRoot[] {(PackageFragmentRoot) existing, root});
 					} else {
 						IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) existing;
 						int rootLength = roots.length;
@@ -226,7 +223,7 @@
 						if (containsRoot) {
 							System.arraycopy(roots, 0, roots = new IPackageFragmentRoot[rootLength+1], 0, rootLength);
 							roots[rootLength] = root;
-							this.packageFragments.put(pkgName, roots);
+							this.workingCopyFragmentsCache.put(pkgName, roots);
 						}
 					}
 				}
@@ -325,18 +322,26 @@
 		if (index != -1) {
 			cuName= cuName.substring(0, index);
 		}
-		Object value = this.packageFragments.get(pkgName);
-		if (value != null) {
-			if (value instanceof PackageFragmentRoot) {
-				return findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) value);
-			} else {
-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
-				for (int i= 0; i < roots.length; i++) {
-					PackageFragmentRoot root= (PackageFragmentRoot) roots[i];
-					ICompilationUnit cu = findCompilationUnit(pkgName, cuName, root);
-					if (cu != null)
-						return cu;
-				}
+		// lookup working copies package fragments
+		Object value = this.workingCopyFragmentsCache.get(pkgName);
+		if (value == null)
+			return null;
+		if (value instanceof PackageFragmentRoot) {
+			return findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) value);
+		} else {
+			IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
+			for (int i = 0, length = roots.length; i < length; i++) {
+				ICompilationUnit cu = findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) roots[i]);
+				if (cu != null)
+					return cu;
+			}
+		}
+		// lookup other package fragments
+		for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+			if (this.packageFragmentsCaches[i].containsKey(pkgName)) {
+				ICompilationUnit cu = findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) this.packageFragmentRoots[i]);
+				if (cu != null)
+					return cu;
 			}
 		}
 		return null;
@@ -421,21 +426,10 @@
 					try {
 						IClasspathEntry entry = project.getClasspathEntryFor(path);
 						if (entry != null) {
-							IPackageFragmentRoot root =
-								project.getPackageFragmentRoot(project.getResource());
-							Object defaultPkgRoot = this.packageFragments.get(CharOperation.NO_STRINGS);
-							if (defaultPkgRoot == null) {
-								return null;
-							}
-							if (defaultPkgRoot instanceof PackageFragmentRoot && defaultPkgRoot.equals(root))
-								return  ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
-							else {
-								IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) defaultPkgRoot;
-								for (int i = 0; i < roots.length; i++) {
-									if (roots[i].equals(root)) {
-										return  ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
-									}
-								}
+							IPackageFragmentRoot root = project.getPackageFragmentRoot(project.getResource());
+							for (int i = 0, length = this.packageFragmentRoots.length; i < length; i++) {
+								if (root.equals(this.packageFragmentRoots[i]))
+									return ((PackageFragmentRoot) root).getPackageFragment(CharOperation.NO_STRINGS);
 							}
 						}
 					} catch (JavaModelException e) {
@@ -460,15 +454,17 @@
 	 *	only exact name matches qualify when <code>false</code>
 	 */
 	public IPackageFragment[] findPackageFragments(String name, boolean partialMatch) {
+		IPackageFragment[] oneFragment = null;
+		ArrayList pkgs = null;
+		HashSet knownPkgs = null;
 		if (partialMatch) {
 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
-			IPackageFragment[] oneFragment = null;
-			ArrayList pkgs = null;
-			Object[][] keys = this.packageFragments.keyTable;
+			// lookup working copies package fragments
+			Object[][] keys = this.workingCopyFragmentsCache.keyTable;
 			for (int i = 0, length = keys.length; i < length; i++) {
 				String[] pkgName = (String[]) keys[i];
 				if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
-					Object value = this.packageFragments.valueTable[i];
+					Object value = this.workingCopyFragmentsCache.valueTable[i];
 					if (value instanceof PackageFragmentRoot) {
 						IPackageFragment pkg = ((PackageFragmentRoot) value).getPackageFragment(pkgName);
 						if (oneFragment == null) {
@@ -477,8 +473,11 @@
 							if (pkgs == null) {
 								pkgs = new ArrayList();
 								pkgs.add(oneFragment[0]);
+								knownPkgs = new HashSet();
+								knownPkgs.add(oneFragment[0]);
 							}
-							pkgs.add(pkg);
+							if (!knownPkgs.contains(pkg))
+								pkgs.add(pkg);
 						}
 					} else {
 						IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
@@ -491,13 +490,40 @@
 								if (pkgs == null) {
 									pkgs = new ArrayList();
 									pkgs.add(oneFragment[0]);
+									knownPkgs = new HashSet();
+									knownPkgs.add(oneFragment[0]);
 								}
-								pkgs.add(pkg);
+								if (!knownPkgs.contains(pkg))
+									pkgs.add(pkg);
 							}
 						}
 					}
 				}
 			}
+			// lookup other package fragments
+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+				HashtableOfArrayToObject packageFragmentsCache = this.packageFragmentsCaches[i];
+				PackageFragmentRoot root = (PackageFragmentRoot) this.packageFragmentRoots[i];
+				keys = packageFragmentsCache.keyTable;
+				for (int j = 0, length2 = keys.length; j < length2; j++) {
+					String[] pkgName = (String[]) keys[j];
+					if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
+						IPackageFragment pkg = root.getPackageFragment(pkgName);
+						if (oneFragment == null) {
+							oneFragment = new IPackageFragment[] {pkg};
+						} else {
+							if (pkgs == null) {
+								pkgs = new ArrayList();
+								pkgs.add(oneFragment[0]);
+								knownPkgs = new HashSet();
+								knownPkgs.add(oneFragment[0]);
+							}
+							if (!knownPkgs.contains(pkg))
+								pkgs.add(pkg);
+						}
+					}
+				}
+			}
 			if (pkgs == null) return oneFragment;
 			int resultLength = pkgs.size();
 			IPackageFragment[] result = new IPackageFragment[resultLength];
@@ -505,19 +531,45 @@
 			return result;
 		} else {
 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
-			Object value = this.packageFragments.get(splittedName);
-			if (value == null)
-				return null;
-			if (value instanceof PackageFragmentRoot) {
-				return new IPackageFragment[] {((PackageFragmentRoot) value).getPackageFragment(splittedName)};
-			} else {
-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
-				IPackageFragment[] result = new IPackageFragment[roots.length];
-				for (int i= 0; i < roots.length; i++) {
-					result[i] = ((PackageFragmentRoot) roots[i]).getPackageFragment(splittedName);
+			// lookup working copies package fragments
+			Object workingCopyRoot = this.workingCopyFragmentsCache.get(splittedName);
+			if (workingCopyRoot != null) {
+				if (workingCopyRoot instanceof PackageFragmentRoot) {
+					oneFragment = new IPackageFragment[] {((PackageFragmentRoot) workingCopyRoot).getPackageFragment(splittedName)};
+				} else {
+					pkgs = new ArrayList();
+					knownPkgs = new HashSet();
+					IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) workingCopyRoot;
+					for (int i= 0; i < roots.length; i++) {
+						IPackageFragment pkg = ((PackageFragmentRoot) roots[i]).getPackageFragment(splittedName);
+						pkgs.add(pkg);
+						knownPkgs.add(pkg);
+					}
+				}
+			}
+			// lookup other package fragments
+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+				if (this.packageFragmentsCaches[i].containsKey(splittedName)) {
+					IPackageFragment pkg = ((PackageFragmentRoot) this.packageFragmentRoots[i]).getPackageFragment(splittedName);
+					if (oneFragment == null) {
+						oneFragment = new IPackageFragment[] {pkg};
+					} else {
+						if (pkgs == null) {
+							pkgs = new ArrayList();
+							pkgs.add(oneFragment[0]);
+							knownPkgs = new HashSet();
+							knownPkgs.add(oneFragment[0]);
+						}
+						if (!knownPkgs.contains(pkg))
+							pkgs.add(pkg);
+					}
 				}
-				return result;
 			}
+			if (pkgs == null) return oneFragment;
+			int resultLength = pkgs.size();
+			IPackageFragment[] result = new IPackageFragment[resultLength];
+			pkgs.toArray(result);
+			return result;
 		}
 	}
 
@@ -769,7 +821,13 @@
 	}
 	
 	public boolean isPackage(String[] pkgName) {
-		return this.packageFragments.get(pkgName) != null;
+		if (this.workingCopyFragmentsCache.containsKey(pkgName))
+			return true;
+		for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+			if (this.packageFragmentsCaches[i].containsKey(pkgName))
+				return true;
+		}
+		return false;
 	}
 
 	/**
@@ -826,13 +884,14 @@
 		}
 */		if (partialMatch) {
 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
-			Object[][] keys = this.packageFragments.keyTable;
+			// lookup working copies package fragments
+			Object[][] keys = this.workingCopyFragmentsCache.keyTable;
 			for (int i = 0, length = keys.length; i < length; i++) {
 				if (requestor.isCanceled())
 					return;
 				String[] pkgName = (String[]) keys[i];
 				if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
-					Object value = this.packageFragments.valueTable[i];
+					Object value = this.workingCopyFragmentsCache.valueTable[i];
 					if (value instanceof PackageFragmentRoot) {
 						PackageFragmentRoot root = (PackageFragmentRoot) value;
 						requestor.acceptPackageFragment(root.getPackageFragment(pkgName));				
@@ -847,13 +906,28 @@
 					}
 				}
 			}
+			// lookup other package fragments
+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+				HashtableOfArrayToObject packageFragmentCache = this.packageFragmentsCaches[i];
+				PackageFragmentRoot root = (PackageFragmentRoot) this.packageFragmentRoots[i];
+				keys = packageFragmentCache.keyTable;
+				for (int j = 0, length2 = keys.length; j < length2; j++) {
+					if (requestor.isCanceled())
+						return;
+					String[] pkgName = (String[]) keys[j];
+					if (pkgName != null && Util.startsWithIgnoreCase(pkgName, splittedName)) {
+						requestor.acceptPackageFragment(root.getPackageFragment(pkgName));				
+					}
+				}
+			}
 		} else {
 			String[] splittedName = Util.splitOn('.', name, 0, name.length());
-			Object value = this.packageFragments.get(splittedName);
-			if (value instanceof PackageFragmentRoot) {
-				requestor.acceptPackageFragment(((PackageFragmentRoot) value).getPackageFragment(splittedName));
+			// lookup working copies package fragments
+			Object workingCopyRoot = this.workingCopyFragmentsCache.get(splittedName);
+			if (workingCopyRoot instanceof PackageFragmentRoot) {
+				requestor.acceptPackageFragment(((PackageFragmentRoot) workingCopyRoot).getPackageFragment(splittedName));
 			} else {
-				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
+				IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) workingCopyRoot;
 				if (roots != null) {
 					for (int i = 0, length = roots.length; i < length; i++) {
 						if (requestor.isCanceled())
@@ -862,6 +936,14 @@
 						requestor.acceptPackageFragment(root.getPackageFragment(splittedName));
 					}
 				}
+			}	
+			// lookup other package fragments
+			for (int i = 0, length = this.packageFragmentsCaches.length; i < length; i++) {
+				if (requestor.isCanceled())
+					return;
+				if (this.packageFragmentsCaches[i].containsKey(splittedName)) {
+					requestor.acceptPackageFragment(((PackageFragmentRoot) this.packageFragmentRoots[i]).getPackageFragment(splittedName));
+				}
 			}
 		}
 	}