diff --git a/org.eclipse.ajdt.core/src/org/eclipse/ajdt/core/AspectJCorePreferences.java b/org.eclipse.ajdt.core/src/org/eclipse/ajdt/core/AspectJCorePreferences.java
index 3d5730a..992502f 100755
--- a/org.eclipse.ajdt.core/src/org/eclipse/ajdt/core/AspectJCorePreferences.java
+++ b/org.eclipse.ajdt.core/src/org/eclipse/ajdt/core/AspectJCorePreferences.java
@@ -43,38 +43,36 @@
  * names have been kept for compatibility.
  */
 public class AspectJCorePreferences {
-			
-    public static final String OPTION_IncrementalCompilationOptimizations = "org.eclipse.ajdt.core.builder.incrementalCompilationOptimizations"; //$NON-NLS-1$
 
-    
+	public static final String OPTION_IncrementalCompilationOptimizations = "org.eclipse.ajdt.core.builder.incrementalCompilationOptimizations"; //$NON-NLS-1$
+
 	public static final String ASPECTPATH_ATTRIBUTE_NAME = "org.eclipse.ajdt.aspectpath"; //$NON-NLS-1$
 	public static final String INPATH_ATTRIBUTE_NAME = "org.eclipse.ajdt.inpath"; //$NON-NLS-1$
-	
-	// see ajdt.ui's plugin.xml and the org.eclipse.jdt.ui.classpathAttributeConfiguration extension point
+
+	// see ajdt.ui's plugin.xml and the
+	// org.eclipse.jdt.ui.classpathAttributeConfiguration extension point
 	public static final String INPATH_RESTRICTION_ATTRIBUTE_NAME = "org.eclipse.ajdt.inpath.restriction"; //$NON-NLS-1$
 	public static final String ASPECTPATH_RESTRICTION_ATTRIBUTE_NAME = "org.eclipse.ajdt.aspectpath.restriction"; //$NON-NLS-1$
 
+	/**
+	 * The value may be filled in with the container that contains this
+	 * classpath entry So when checking to see if a classpath entry has this
+	 * attribute, use {@link #isOnAspectpath(IClasspathEntry)}
+	 */
+	public static final IClasspathAttribute ASPECTPATH_ATTRIBUTE = JavaCore
+			.newClasspathAttribute(ASPECTPATH_ATTRIBUTE_NAME, ASPECTPATH_ATTRIBUTE_NAME); // $NON-NLS-1$
 
 	/**
-	 *  The value may be filled in with the container that contains this classpath entry
-	 *  So when checking to see if a classpath entry has this attribute, use {@link #isOnAspectpath(IClasspathEntry)} 
+	 * The value may be filled in with the container that contains this
+	 * classpath entry So when checking to see if a classpath entry has this
+	 * attribute, use {@link #isOnInpath(IClasspathEntry)}
 	 */
-	public static final IClasspathAttribute ASPECTPATH_ATTRIBUTE = JavaCore.newClasspathAttribute(
-			ASPECTPATH_ATTRIBUTE_NAME, ASPECTPATH_ATTRIBUTE_NAME); //$NON-NLS-1$
+	public static final IClasspathAttribute INPATH_ATTRIBUTE = JavaCore.newClasspathAttribute(INPATH_ATTRIBUTE_NAME,
+			INPATH_ATTRIBUTE_NAME); // $NON-NLS-1$
 
-	/**
-	 *  The value may be filled in with the container that contains this classpath entry
-	 *  So when checking to see if a classpath entry has this attribute, use {@link #isOnInpath(IClasspathEntry)} 
-	 */
-	public static final IClasspathAttribute INPATH_ATTRIBUTE = JavaCore.newClasspathAttribute(
-			INPATH_ATTRIBUTE_NAME, INPATH_ATTRIBUTE_NAME); //$NON-NLS-1$
+	public static final String OUT_JAR = "org.eclipse.ajdt.ui.outJar"; //$NON-NLS-1$
 
-	
-	
-	
-    public static final String OUT_JAR = "org.eclipse.ajdt.ui.outJar"; //$NON-NLS-1$
-
-    public static final String INPATH_OUT_FOLDER = "org.eclipse.ajdt.ui.inpathOutFolder"; //$NON-NLS-1$
+	public static final String INPATH_OUT_FOLDER = "org.eclipse.ajdt.ui.inpathOutFolder"; //$NON-NLS-1$
 
 	public static final String ASPECTPATH = "org.eclipse.ajdt.ui.aspectPath"; //$NON-NLS-1$
 
@@ -89,141 +87,133 @@
 	public static final String INPATH_ENT_KINDS = "org.eclipse.ajdt.ui.inPath.entryKind"; //$NON-NLS-1$
 
 	public static String getProjectOutJar(IProject project) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        return projectNode.get(OUT_JAR, ""); //$NON-NLS-1$
-    }
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		return projectNode.get(OUT_JAR, ""); //$NON-NLS-1$
+	}
 
-    public static String getProjectInpathOutFolder(IProject project) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        return projectNode.get(INPATH_OUT_FOLDER, null);
-    }
+	public static String getProjectInpathOutFolder(IProject project) {
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		return projectNode.get(INPATH_OUT_FOLDER, null);
+	}
 
-    public static void setProjectOutJar(IProject project, String value) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        projectNode.put(OUT_JAR, value);
-        if (value.length() == 0) {
-            projectNode.remove(OUT_JAR);
-        }
-        try {
-            projectNode.flush();
-        } catch (BackingStoreException e) {
-        }
-    }
+	public static void setProjectOutJar(IProject project, String value) {
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		projectNode.put(OUT_JAR, value);
+		if (value.length() == 0) {
+			projectNode.remove(OUT_JAR);
+		}
+		try {
+			projectNode.flush();
+		} catch (BackingStoreException e) {
+		}
+	}
 
-    public static void setProjectInpathOutFolder(IProject project, String value) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        if (value == null || value.length() == 0) {
-            projectNode.remove(INPATH_OUT_FOLDER);
-        } else {
-            projectNode.put(INPATH_OUT_FOLDER, value);
-        }
-        try {
-            projectNode.flush();
-        } catch (BackingStoreException e) {
-        }
-    }
+	public static void setProjectInpathOutFolder(IProject project, String value) {
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		if (value == null || value.length() == 0) {
+			projectNode.remove(INPATH_OUT_FOLDER);
+		} else {
+			projectNode.put(INPATH_OUT_FOLDER, value);
+		}
+		try {
+			projectNode.flush();
+		} catch (BackingStoreException e) {
+		}
+	}
 
-    public static void setProjectAspectPath(IProject project, String path,
-            String cKinds, String eKinds) {
-        setProjectPath(project, path, cKinds, eKinds, ASPECTPATH_ATTRIBUTE);
-    }
-    public static String[] getRawProjectAspectPath(IProject project) {
-        return internalGetProjectPath(project, ASPECTPATH_ATTRIBUTE, false);
-    }
-    
-    public static String[] getResolvedProjectAspectPath(IProject project) {
-        return internalGetProjectPath(project, ASPECTPATH_ATTRIBUTE, true);
-    }
-    
+	public static void setProjectAspectPath(IProject project, String path, String cKinds, String eKinds) {
+		setProjectPath(project, path, cKinds, eKinds, ASPECTPATH_ATTRIBUTE);
+	}
+
+	public static String[] getRawProjectAspectPath(IProject project) {
+		return internalGetProjectPath(project, ASPECTPATH_ATTRIBUTE, false);
+	}
+
+	public static String[] getResolvedProjectAspectPath(IProject project) {
+		return internalGetProjectPath(project, ASPECTPATH_ATTRIBUTE, true);
+	}
 
 	public static void addToAspectPath(IProject project, IClasspathEntry entry) {
 		IJavaProject jp = JavaCore.create(project);
-		addAttribute(jp,entry,AspectJCorePreferences.ASPECTPATH_ATTRIBUTE);
+		addAttribute(jp, entry, AspectJCorePreferences.ASPECTPATH_ATTRIBUTE);
 	}
 
 	public static void removeFromAspectPath(IProject project, IClasspathEntry entry) {
 		IJavaProject jp = JavaCore.create(project);
-		removeAttribute(jp,entry,AspectJCorePreferences.ASPECTPATH_ATTRIBUTE);
+		removeAttribute(jp, entry, AspectJCorePreferences.ASPECTPATH_ATTRIBUTE);
 	}
-	
-   public static void addToAspectPath(IProject project, String jarPath, int eKind) {
-       addAttribute(project, jarPath, eKind, ASPECTPATH_ATTRIBUTE);
-   }
 
+	public static void addToAspectPath(IProject project, String jarPath, int eKind) {
+		addAttribute(project, jarPath, eKind, ASPECTPATH_ATTRIBUTE);
+	}
 
 	public static boolean isOnAspectpath(IClasspathEntry entry) {
 		IClasspathAttribute[] attributes = entry.getExtraAttributes();
 		for (int j = 0; j < attributes.length; j++) {
 			if (isAspectPathAttribute(attributes[j])) {
-				return true;								
+				return true;
 			}
 		}
 		return false;
 	}
-	
+
 	public static boolean isAspectPathAttribute(IClasspathAttribute attribute) {
 		return attribute.getName().equals(AspectJCorePreferences.ASPECTPATH_ATTRIBUTE.getName());
 	}
 
-    /**
-     * determines if an element is on the aspect path taking into account
-     * the restrictions of the classpath container entry
-     */
-    public static boolean isOnAspectpathWithRestrictions(IClasspathEntry entry, String item) {
-        if (!isOnAspectpath(entry)) {
-            return false;
-        }
-        
-        Set<String> restrictions = findContainerRestrictions(entry, true);
-        if (restrictions == null) {
-            // no restrictions, assume the jar entry is on the path
-            return true;
-        } else {
-            for (String restriction : restrictions) {
-                if (item.indexOf(restriction) != -1) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-    
-    /**
-     * determines if an element is on the aspect path taking into account
-     * the restrictions of the classpath container entry
-     */
-    public static boolean isOnInpathWithRestrictions(IClasspathEntry entry, String item) {
-        if (!isOnInpath(entry)) {
-            return false;
-        }
-        
-        Set<String> restrictions = findContainerRestrictions(entry, false);
-        if (restrictions == null || restrictions.isEmpty()) {
-            // no restrictions, assume the jar entry is on the path
-            return true;
-        } else {
-            for (String restriction : restrictions) {
-                if (item.indexOf(restriction) != -1) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-    
-	
-	
-    /**
-     * Checks to see if an entry is already on the aspect path
-     */
+	/**
+	 * determines if an element is on the aspect path taking into account the
+	 * restrictions of the classpath container entry
+	 */
+	public static boolean isOnAspectpathWithRestrictions(IClasspathEntry entry, String item) {
+		if (!isOnAspectpath(entry)) {
+			return false;
+		}
+
+		Set<String> restrictions = findContainerRestrictions(entry, true);
+		if (restrictions == null) {
+			// no restrictions, assume the jar entry is on the path
+			return true;
+		} else {
+			for (String restriction : restrictions) {
+				if (item.indexOf(restriction) != -1) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+
+	/**
+	 * determines if an element is on the aspect path taking into account the
+	 * restrictions of the classpath container entry
+	 */
+	public static boolean isOnInpathWithRestrictions(IClasspathEntry entry, String item) {
+		if (!isOnInpath(entry)) {
+			return false;
+		}
+
+		Set<String> restrictions = findContainerRestrictions(entry, false);
+		if (restrictions == null || restrictions.isEmpty()) {
+			// no restrictions, assume the jar entry is on the path
+			return true;
+		} else {
+			for (String restriction : restrictions) {
+				if (item.indexOf(restriction) != -1) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+
+	/**
+	 * Checks to see if an entry is already on the aspect path
+	 */
 	public static boolean isOnAspectpath(IProject project, String path) {
 		IJavaProject jp = JavaCore.create(project);
 		try {
@@ -235,13 +225,12 @@
 						|| (cp[i].getEntryKind() == IClasspathEntry.CPE_PROJECT)) {
 					IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(cp[i]);
 					if (resolvedClasspathEntry != null) {
-                        String entry = resolvedClasspathEntry
-    							.getPath().toPortableString();
-    					if (entry.equals(path)) {
-    						if (isOnAspectpath(cp[i])) {
-    							return true;
-    						}
-    					}
+						String entry = resolvedClasspathEntry.getPath().toPortableString();
+						if (entry.equals(path)) {
+							if (isOnAspectpath(cp[i])) {
+								return true;
+							}
+						}
 					}
 				}
 			}
@@ -251,215 +240,219 @@
 	}
 
 	public static String[] getRawProjectInpath(IProject project) {
-        return internalGetProjectPath(project, INPATH_ATTRIBUTE, false);
-    }
+		return internalGetProjectPath(project, INPATH_ATTRIBUTE, false);
+	}
 
-    public static String[] getResolvedProjectInpath(IProject project) {
-        return internalGetProjectPath(project, INPATH_ATTRIBUTE, true);
-    }
+	public static String[] getResolvedProjectInpath(IProject project) {
+		return internalGetProjectPath(project, INPATH_ATTRIBUTE, true);
+	}
 
-    public static List<IClasspathEntry> resolveDependentProjectClasspath(IClasspathEntry projEntry, IProject requiredProj) {
-        // add all output locations and exported classpath entities
-        // AspectJ compiler doesn't understand the concept of a java project
-        List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
-        
+	public static List<IClasspathEntry> resolveDependentProjectClasspath(IClasspathEntry projEntry,
+			IProject requiredProj) {
+		// add all output locations and exported classpath entities
+		// AspectJ compiler doesn't understand the concept of a java project
+		List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
 
-        try {
-            JavaProject requiredJavaProj = (JavaProject) JavaCore.create(requiredProj);
-            // bug 288395 Do not use the default mechanism for resolving classpath here
-            // this will look into jar files at the Classpath header in the jar's manifest
-            // and include jar files that are potentially missing, but have no effect on
-            // the build.
-            Object resolvedClasspath = requiredJavaProj.resolveClasspath(requiredJavaProj.getRawClasspath(), true, false);
-            IClasspathEntry[] requiredEntries = extractRequiredEntries(resolvedClasspath);
-            for (int i = 0; i < requiredEntries.length; i++) {
-                IClasspathEntry requiredEntry = requiredEntries[i];
-                if (requiredEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
+		try {
+			JavaProject requiredJavaProj = (JavaProject) JavaCore.create(requiredProj);
+			// bug 288395 Do not use the default mechanism for resolving
+			// classpath here
+			// this will look into jar files at the Classpath header in the
+			// jar's manifest
+			// and include jar files that are potentially missing, but have no
+			// effect on
+			// the build.
+			Object resolvedClasspath = requiredJavaProj.resolveClasspath(requiredJavaProj.getRawClasspath(), true,
+					false);
+			IClasspathEntry[] requiredEntries = extractRequiredEntries(resolvedClasspath);
+			for (int i = 0; i < requiredEntries.length; i++) {
+				IClasspathEntry requiredEntry = requiredEntries[i];
+				if (requiredEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
 
-                    // always add source entries even if not explicitly exported
-                    // don't add the source folder itself, but instead add the outfolder
-                    IPath outputLocation = requiredEntry.getOutputLocation();
-                    if (outputLocation != null) {
-            	        IAccessRule[] rules = projEntry.getAccessRules();
-                	    IClasspathAttribute[] attributes = projEntry.getExtraAttributes();
+					// always add source entries even if not explicitly exported
+					// don't add the source folder itself, but instead add the
+					// outfolder
+					IPath outputLocation = requiredEntry.getOutputLocation();
+					if (outputLocation != null) {
+						IAccessRule[] rules = projEntry.getAccessRules();
+						IClasspathAttribute[] attributes = projEntry.getExtraAttributes();
 
-                	    // only add the out folder if it already exists
-                	    if (requiredProj.getFolder(outputLocation.removeFirstSegments(1)).exists()) {
-                            IClasspathEntry outFolder = JavaCore.newLibraryEntry(outputLocation,
-                                    requiredEntry.getPath(),
-                                    requiredProj.getFullPath(), rules, attributes, projEntry.isExported());
-                            actualEntries.add(outFolder);
-                	    }
-                    }
-                } else if (requiredEntry.isExported()) {
-                    // must recur through this entry and add entries that it contains
-                    actualEntries.addAll(resolveClasspath(requiredEntry, requiredProj));
-                    
-                }
-            } // for (int i = 0; i < requiredEntries.length; i++)
-            
-            IPath outputLocation = requiredJavaProj.getOutputLocation();
-            // Output location may not exist.  Do not put output location of required project
-            // on path unless it exists
-            boolean exists = false;
-            // bug 244330 check to see if the project folder is also the output folder
-            if (outputLocation.segmentCount() == 1) {
-            	exists = true;
-            } else {
-            	if (requiredProj.getWorkspace().getRoot().getFolder(outputLocation).exists()) {
-            		exists = true;
-            	}
-            }
-            
-            if (exists) {
-                IClasspathEntry outFolder = JavaCore.newLibraryEntry(outputLocation,
-                                                                     null,
-                                                                     requiredProj.getFullPath());					                
-                actualEntries.add(outFolder);
-            }
-        } catch (JavaModelException e) {
-        }
-        return actualEntries;
-    }
+						// only add the out folder if it already exists
+						if (requiredProj.getFolder(outputLocation.removeFirstSegments(1)).exists()) {
+							IClasspathEntry outFolder = JavaCore.newLibraryEntry(outputLocation,
+									requiredEntry.getPath(), requiredProj.getFullPath(), rules, attributes,
+									projEntry.isExported());
+							actualEntries.add(outFolder);
+						}
+					}
+				} else if (requiredEntry.isExported()) {
+					// must recur through this entry and add entries that it
+					// contains
+					actualEntries.addAll(resolveClasspath(requiredEntry, requiredProj));
 
-    
-    /**
-     * resolvedClasspath is a package protected static class inside JavaProject
-     * must use reflection to access it 
-     */
-    @SuppressWarnings({ "unchecked" })
-    private static IClasspathEntry[] extractRequiredEntries(
-            Object resolvedClasspath) {
-        
-        try {
-            Class resolvedClasspathClass = Class.forName("org.eclipse.jdt.internal.core.JavaProject$ResolvedClasspath");
-            return (IClasspathEntry[]) ReflectionUtils.getPrivateField(resolvedClasspathClass, "resolvedClasspath", resolvedClasspath);
-        } catch (Exception e) {
-            return new IClasspathEntry[0];
-        }
-    }
+				}
+			} // for (int i = 0; i < requiredEntries.length; i++)
 
-    public static List<IClasspathEntry> resolveClasspathContainer(IClasspathEntry classpathContainerEntry, IProject thisProject) 
-            throws JavaModelException {
-        IJavaProject thisJavaProject = JavaCore.create(thisProject);
-        IClasspathContainer container = 
-            JavaCore.getClasspathContainer(classpathContainerEntry.getPath(), thisJavaProject);
-        if (container != null) {
-            List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
-            IClasspathEntry[] containerEntries = container.getClasspathEntries();
-            for (int i = 0; i < containerEntries.length; i++) {
-                // projects must be resolved specially since the AspectJ doesn't understand the 
-                // concept of project
-                switch (containerEntries[i].getEntryKind()) {
-                    case IClasspathEntry.CPE_PROJECT:
-                        IProject requiredProj = thisProject.getWorkspace().getRoot().getProject(
-                                containerEntries[i].getPath().makeRelative().toPortableString());
-                        if (! requiredProj.getName().equals(thisProject.getName())   
-                                && requiredProj.exists()) {
-                            actualEntries.addAll(resolveDependentProjectClasspath(containerEntries[i], requiredProj));
-                        }
-                        break;
+			IPath outputLocation = requiredJavaProj.getOutputLocation();
+			// Output location may not exist. Do not put output location of
+			// required project
+			// on path unless it exists
+			boolean exists = false;
+			// bug 244330 check to see if the project folder is also the output
+			// folder
+			if (outputLocation.segmentCount() == 1) {
+				exists = true;
+			} else {
+				if (requiredProj.getWorkspace().getRoot().getFolder(outputLocation).exists()) {
+					exists = true;
+				}
+			}
 
-                    case IClasspathEntry.CPE_VARIABLE:
-                        IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(
-                                containerEntries[i]);
-                        if (resolvedClasspathEntry != null) {
-                            actualEntries.add(
-                                    resolvedClasspathEntry);
-                        }
-                        break;
-                        
-                    case IClasspathEntry.CPE_CONTAINER:
-                        // not sure if we can have this, but try anyway
-                        actualEntries.addAll(resolveClasspathContainer(containerEntries[i], thisProject));
-                        break;
-                    case IClasspathEntry.CPE_LIBRARY:
-                        actualEntries.add(containerEntries[i]);
-                        break;
-                    default:
-                        // do nothing
-                }
-            }
-            return actualEntries;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-    
-    /**
-     * Resolves a single classpath entry
-     * @param entry the classpath entry to resolve
-     * @param thisProject the java project that has this entry
-     * @return the resolved list of classpath entries
-     * @throws JavaModelException 
-     */
-    public static List<IClasspathEntry> resolveClasspath(IClasspathEntry entry, IProject thisProject) throws JavaModelException {
-        switch(entry.getEntryKind()) {
-            case IClasspathEntry.CPE_CONTAINER:
-                return resolveClasspathContainer(entry, thisProject);
-                
-            case IClasspathEntry.CPE_LIBRARY:
-                return Collections.singletonList(entry);
-                
-            case IClasspathEntry.CPE_PROJECT:
-                IProject containedProj = thisProject.getWorkspace().getRoot().getProject(
-                        entry.getPath().makeRelative().toPortableString());
-                if (! containedProj.getName().equals(thisProject.getName())   
-                        && containedProj.exists()) {
-                    return resolveDependentProjectClasspath(entry, containedProj);
-                } else {
-                    return Collections.emptyList();
-                }
-                    
-            case IClasspathEntry.CPE_VARIABLE:
-                IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(entry);
-                if (resolvedClasspathEntry != null) {
-                    return Collections.singletonList(resolvedClasspathEntry);
-                } else {
-                    return Collections.emptyList();
-                }
-            default:
-                return Collections.emptyList();
-        }
-    }
+			if (exists) {
+				IClasspathEntry outFolder = JavaCore.newLibraryEntry(outputLocation, null, requiredProj.getFullPath());
+				actualEntries.add(outFolder);
+			}
+		} catch (JavaModelException e) {
+		}
+		return actualEntries;
+	}
 
-	public static void setProjectInPath(IProject project, String path,
-			String cKinds, String eKinds) {
-        setProjectPath(project, path, cKinds, eKinds, INPATH_ATTRIBUTE);
+	/**
+	 * resolvedClasspath is a package protected static class inside JavaProject
+	 * must use reflection to access it
+	 */
+	@SuppressWarnings({ "unchecked" })
+	private static IClasspathEntry[] extractRequiredEntries(Object resolvedClasspath) {
+
+		try {
+			Class resolvedClasspathClass = Class.forName("org.eclipse.jdt.internal.core.JavaProject$ResolvedClasspath");
+			return (IClasspathEntry[]) ReflectionUtils.getPrivateField(resolvedClasspathClass, "resolvedClasspath",
+					resolvedClasspath);
+		} catch (Exception e) {
+			return new IClasspathEntry[0];
+		}
+	}
+
+	public static List<IClasspathEntry> resolveClasspathContainer(IClasspathEntry classpathContainerEntry,
+			IProject thisProject) throws JavaModelException {
+		IJavaProject thisJavaProject = JavaCore.create(thisProject);
+		IClasspathContainer container = JavaCore.getClasspathContainer(classpathContainerEntry.getPath(),
+				thisJavaProject);
+		if (container != null) {
+			List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
+			IClasspathEntry[] containerEntries = container.getClasspathEntries();
+			for (int i = 0; i < containerEntries.length; i++) {
+				// projects must be resolved specially since the AspectJ doesn't
+				// understand the
+				// concept of project
+				switch (containerEntries[i].getEntryKind()) {
+				case IClasspathEntry.CPE_PROJECT:
+					IProject requiredProj = thisProject.getWorkspace().getRoot()
+							.getProject(containerEntries[i].getPath().makeRelative().toPortableString());
+					if (!requiredProj.getName().equals(thisProject.getName()) && requiredProj.exists()) {
+						actualEntries.addAll(resolveDependentProjectClasspath(containerEntries[i], requiredProj));
+					}
+					break;
+
+				case IClasspathEntry.CPE_VARIABLE:
+					IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(containerEntries[i]);
+					if (resolvedClasspathEntry != null) {
+						actualEntries.add(resolvedClasspathEntry);
+					}
+					break;
+
+				case IClasspathEntry.CPE_CONTAINER:
+					// not sure if we can have this, but try anyway
+					actualEntries.addAll(resolveClasspathContainer(containerEntries[i], thisProject));
+					break;
+				case IClasspathEntry.CPE_LIBRARY:
+					actualEntries.add(containerEntries[i]);
+					break;
+				default:
+					// do nothing
+				}
+			}
+			return actualEntries;
+		} else {
+			return Collections.emptyList();
+		}
+	}
+
+	/**
+	 * Resolves a single classpath entry
+	 * 
+	 * @param entry
+	 *            the classpath entry to resolve
+	 * @param thisProject
+	 *            the java project that has this entry
+	 * @return the resolved list of classpath entries
+	 * @throws JavaModelException
+	 */
+	public static List<IClasspathEntry> resolveClasspath(IClasspathEntry entry, IProject thisProject)
+			throws JavaModelException {
+		switch (entry.getEntryKind()) {
+		case IClasspathEntry.CPE_CONTAINER:
+			return resolveClasspathContainer(entry, thisProject);
+
+		case IClasspathEntry.CPE_LIBRARY:
+			return Collections.singletonList(entry);
+
+		case IClasspathEntry.CPE_PROJECT:
+			IProject containedProj = thisProject.getWorkspace().getRoot()
+					.getProject(entry.getPath().makeRelative().toPortableString());
+			if (!containedProj.getName().equals(thisProject.getName()) && containedProj.exists()) {
+				return resolveDependentProjectClasspath(entry, containedProj);
+			} else {
+				return Collections.emptyList();
+			}
+
+		case IClasspathEntry.CPE_VARIABLE:
+			IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(entry);
+			if (resolvedClasspathEntry != null) {
+				return Collections.singletonList(resolvedClasspathEntry);
+			} else {
+				return Collections.emptyList();
+			}
+		default:
+			return Collections.emptyList();
+		}
+	}
+
+	public static void setProjectInPath(IProject project, String path, String cKinds, String eKinds) {
+		setProjectPath(project, path, cKinds, eKinds, INPATH_ATTRIBUTE);
 	}
 
 	public static void addToInPath(IProject project, IClasspathEntry entry) {
 		IJavaProject jp = JavaCore.create(project);
-		addAttribute(jp,entry,AspectJCorePreferences.INPATH_ATTRIBUTE);
-	}
-	
-	public static void removeFromInPath(IProject project, IClasspathEntry entry) {
-		IJavaProject jp = JavaCore.create(project);
-		removeAttribute(jp,entry,AspectJCorePreferences.INPATH_ATTRIBUTE);
-	}
-	
-	public static void addToInPath(IProject project, String jarPath, int eKind) {
-	    addAttribute(project, jarPath, eKind, INPATH_ATTRIBUTE);
+		addAttribute(jp, entry, AspectJCorePreferences.INPATH_ATTRIBUTE);
 	}
 
-	
-    public static boolean isOnInpath(IClasspathEntry entry) {
+	public static void removeFromInPath(IProject project, IClasspathEntry entry) {
+		IJavaProject jp = JavaCore.create(project);
+		removeAttribute(jp, entry, AspectJCorePreferences.INPATH_ATTRIBUTE);
+	}
+
+	public static void addToInPath(IProject project, String jarPath, int eKind) {
+		addAttribute(project, jarPath, eKind, INPATH_ATTRIBUTE);
+	}
+
+	public static boolean isOnInpath(IClasspathEntry entry) {
 		IClasspathAttribute[] attributes = entry.getExtraAttributes();
 		for (int j = 0; j < attributes.length; j++) {
 			if (isInPathAttribute(attributes[j])) {
-				return true;								
+				return true;
 			}
 		}
 		return false;
 	}
-    
-    public static boolean isOnPath(IClasspathEntry entry, boolean aspectpath) {
-        return aspectpath ? isOnAspectpath(entry) : isOnInpath(entry);
-    }
+
+	public static boolean isOnPath(IClasspathEntry entry, boolean aspectpath) {
+		return aspectpath ? isOnAspectpath(entry) : isOnInpath(entry);
+	}
 
 	/**
-     * Checks to see if an entry is already on the Inpath
-     */
+	 * Checks to see if an entry is already on the Inpath
+	 */
 	public static boolean isOnInpath(IProject project, String jarPath) {
 		IJavaProject jp = JavaCore.create(project);
 		try {
@@ -467,16 +460,16 @@
 			for (int i = 0; i < cp.length; i++) {
 				if ((cp[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY)
 						|| (cp[i].getEntryKind() == IClasspathEntry.CPE_VARIABLE)
-				        || (cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER)
-				        || (cp[i].getEntryKind() == IClasspathEntry.CPE_PROJECT)) {
+						|| (cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER)
+						|| (cp[i].getEntryKind() == IClasspathEntry.CPE_PROJECT)) {
 					IClasspathEntry resolvedClasspathEntry = JavaCore.getResolvedClasspathEntry(cp[i]);
 					if (resolvedClasspathEntry != null) {
-					    String entry = resolvedClasspathEntry.getPath().toPortableString();
-    					if (entry.equals(jarPath)) {
-    						if (isOnInpath(cp[i])) {
-    							return true;
-    						}
-    					}
+						String entry = resolvedClasspathEntry.getPath().toPortableString();
+						if (entry.equals(jarPath)) {
+							if (isOnInpath(cp[i])) {
+								return true;
+							}
+						}
 					}
 				}
 			}
@@ -484,467 +477,460 @@
 		}
 		return false;
 	}
-	
 
 	public static boolean isInPathAttribute(IClasspathAttribute attribute) {
 		return attribute.getName().equals(AspectJCorePreferences.INPATH_ATTRIBUTE.getName());
 	}
 
+	public static void setIncrementalCompilationOptimizationsEnabled(boolean value) {
+		IEclipsePreferences store = AspectJPlugin.getDefault().getPreferences();
+		store.putBoolean(OPTION_IncrementalCompilationOptimizations, value);
+	}
 
-    public static void setIncrementalCompilationOptimizationsEnabled(boolean value) {
-        IEclipsePreferences store = AspectJPlugin.getDefault()
-                .getPreferences();
-        store.putBoolean(OPTION_IncrementalCompilationOptimizations, value);
-    }
-    
-    /**
-     * Searches the raw classpath for entries whose paths contain
-     * the strings in putOnPath.
-     * 
-     * Then ensures that these classpath entries are on the aspect path
-     */
-    public static void augmentAspectPath(IProject project, String[] putOnAspectPath) {
-        if (putOnAspectPath.length == 0) {
-            // nothing to do!
-            return;
-        }
-        IJavaProject jp = JavaCore.create(project);
-        List<IClasspathEntry> toPutOnAspectPath = new ArrayList<IClasspathEntry>();
-        try {
-            IClasspathEntry[] cp = jp.getRawClasspath();
-            for (int i = 0; i < cp.length; i++) {
-                String path = cp[i].getPath().toPortableString();
-                for (int j = 0; j < putOnAspectPath.length; j++) {
-                    if (path.indexOf(putOnAspectPath[j]) != -1) {
-                        toPutOnAspectPath.add(cp[i]);
-                    }
-                }
-            }
-            
-            for (IClasspathEntry entry : toPutOnAspectPath) {
-                if (! isOnAspectpath(entry)) {
-                    addToAspectPath(project, entry);
-                }
-            }
-        } catch (JavaModelException e) {
-        }
-    }
+	/**
+	 * Searches the raw classpath for entries whose paths contain the strings in
+	 * putOnPath.
+	 * 
+	 * Then ensures that these classpath entries are on the aspect path
+	 */
+	public static void augmentAspectPath(IProject project, String[] putOnAspectPath) {
+		if (putOnAspectPath.length == 0) {
+			// nothing to do!
+			return;
+		}
+		IJavaProject jp = JavaCore.create(project);
+		List<IClasspathEntry> toPutOnAspectPath = new ArrayList<IClasspathEntry>();
+		try {
+			IClasspathEntry[] cp = jp.getRawClasspath();
+			for (int i = 0; i < cp.length; i++) {
+				String path = cp[i].getPath().toPortableString();
+				for (int j = 0; j < putOnAspectPath.length; j++) {
+					if (path.indexOf(putOnAspectPath[j]) != -1) {
+						toPutOnAspectPath.add(cp[i]);
+					}
+				}
+			}
 
-    /**
-     * Checks to see if the compiler option for incremental build optimizations
-     * is on or off
-     * 
-     * On by default
-     * @return
-     */
-    public static boolean isIncrementalCompilationOptimizationsEnabled() {
-        IEclipsePreferences store = AspectJPlugin.getDefault()
-                .getPreferences();
-        return store.getBoolean(OPTION_IncrementalCompilationOptimizations, true);
-    }
+			for (IClasspathEntry entry : toPutOnAspectPath) {
+				if (!isOnAspectpath(entry)) {
+					addToAspectPath(project, entry);
+				}
+			}
+		} catch (JavaModelException e) {
+		}
+	}
 
-    private static void setProjectPath(IProject project, String path,
-            String cKinds, String eKinds, IClasspathAttribute attribute) {
-    	IJavaProject javaProject = JavaCore.create(project);		
-    	removeAttribute(javaProject, attribute);
-    	
-    	StringTokenizer pathTok = new StringTokenizer(path, File.pathSeparator);
-    	StringTokenizer eKindsTok = new StringTokenizer(eKinds, File.pathSeparator);
-    	int index = 1;
-    	while (pathTok.hasMoreTokens() && eKindsTok.hasMoreTokens()) {
-    		String entry = pathTok.nextToken();
-    		int eKind = Integer.parseInt(eKindsTok.nextToken());
-    		if (ASPECTPATH_ATTRIBUTE.equals(attribute)) {
-    		    addToAspectPath(project,entry, eKind);
-    		} else if (INPATH_ATTRIBUTE.equals(attribute)) {
-    		    addToInPath(project,entry, eKind);
-    		}
-    		index++;
-    	}
-    }
+	/**
+	 * Checks to see if the compiler option for incremental build optimizations
+	 * is on or off
+	 * 
+	 * On by default
+	 * 
+	 * @return
+	 */
+	public static boolean isIncrementalCompilationOptimizationsEnabled() {
+		IEclipsePreferences store = AspectJPlugin.getDefault().getPreferences();
+		return store.getBoolean(OPTION_IncrementalCompilationOptimizations, true);
+	}
 
-    
-    private static boolean shouldCheckOldStylePath(IProject project, String pathKind) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        return projectNode.get(pathKind, "").length() == 0 && projectNode.get(pathKind + "1", "").length() > 0;
-    }
+	private static void setProjectPath(IProject project, String path, String cKinds, String eKinds,
+			IClasspathAttribute attribute) {
+		IJavaProject javaProject = JavaCore.create(project);
+		removeAttribute(javaProject, attribute);
 
-    private static void markOldStylePathAsRead(IProject project, String pathKind) {
-        IScopeContext projectScope = new ProjectScope(project);
-        IEclipsePreferences projectNode = projectScope
-                .getNode(AspectJPlugin.UI_PLUGIN_ID);
-        projectNode.put(pathKind, "visited");
-        try {
-            projectNode.flush();
-        } catch (BackingStoreException e) {
-        }
-    }
-    
-    private static String[] getOldProjectPath(IProject project, boolean aspectPath) {
-        String pathName;
-        String pathConKinds;
-        String pathEntKinds;
-        if (aspectPath) {
-            pathName = ASPECTPATH;
-            pathConKinds = ASPECTPATH_CON_KINDS;
-            pathEntKinds = ASPECTPATH_ENT_KINDS;
-        } else {
-            pathName = INPATH;
-            pathConKinds = INPATH_CON_KINDS;
-            pathEntKinds = INPATH_ENT_KINDS;
-        }
-        
-    	IScopeContext projectScope = new ProjectScope(project);
-    	IEclipsePreferences projectNode = projectScope
-    			.getNode(AspectJPlugin.UI_PLUGIN_ID);
-    	String pathString = ""; //$NON-NLS-1$
-    	int index = 1;
-    	String value = projectNode.get(pathName + index, ""); //$NON-NLS-1$
-    	if (value.length() == 0) {
-    		return null;
-    	}
-    	while (value.length() > 0) {
-    		pathString += value;
-    		pathString += File.pathSeparator;
-    		index++;
-    		value = projectNode.get(pathName + index, ""); //$NON-NLS-1$
-    	}
-    
-    	String contentString = ""; //$NON-NLS-1$
-    	index = 1;
-    	value = projectNode.get(pathConKinds + index, ""); //$NON-NLS-1$
-    	while (value.length() > 0) {
-    		contentString += toContentKind(value.toUpperCase());
-    		contentString += File.pathSeparator;
-    		index++;
-    		value = projectNode.get(pathConKinds + index, ""); //$NON-NLS-1$
-    	}
-    
-    	String entryString = ""; //$NON-NLS-1$
-    	index = 1;
-    	value = projectNode.get(pathEntKinds + index, ""); //$NON-NLS-1$
-    	while (value.length() > 0) {
-    		entryString += toEntryKind(value.toUpperCase());
-    		entryString += File.pathSeparator;
-    		index++;
-    		value = projectNode.get(pathEntKinds + index, ""); //$NON-NLS-1$
-    	}
-    	return new String[] { pathString, contentString, entryString };
-    }
+		StringTokenizer pathTok = new StringTokenizer(path, File.pathSeparator);
+		StringTokenizer eKindsTok = new StringTokenizer(eKinds, File.pathSeparator);
+		int index = 1;
+		while (pathTok.hasMoreTokens() && eKindsTok.hasMoreTokens()) {
+			String entry = pathTok.nextToken();
+			int eKind = Integer.parseInt(eKindsTok.nextToken());
+			if (ASPECTPATH_ATTRIBUTE.equals(attribute)) {
+				addToAspectPath(project, entry, eKind);
+			} else if (INPATH_ATTRIBUTE.equals(attribute)) {
+				addToInPath(project, entry, eKind);
+			}
+			index++;
+		}
+	}
 
-    /**
-     * Firstly, add library to the Java build path if it's not there already,
-     * then mark the entry as being on the aspect path
-     * @param project
-     * @param path
-     */
-    private static void addAttribute(IProject project, String jarPath, int eKind, IClasspathAttribute attribute) {
-    	IJavaProject jp = JavaCore.create(project);
-    	
-    	
-    	try {
-            IClasspathEntry[] cp = jp.getRawClasspath();
-            int cpIndex = getIndexInBuildPathEntry(cp, jarPath);
-            if (cpIndex >= 0) { // already on classpath
-                // add attribute to classpath entry
-                // if it doesn't already exist
-                IClasspathEntry pathAdd = cp[cpIndex];
-                // only add attribute if this element is not already on the path
-                if (isAspectPathAttribute(attribute) ? 
-                        !isOnAspectpath(pathAdd) :
-                        !isOnInpath(pathAdd)) {  
-                    IClasspathAttribute[] attributes = pathAdd.getExtraAttributes();
-                    IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length + 1];
-                    System.arraycopy(attributes, 0, newattrib, 0, attributes.length);
-                    newattrib[attributes.length] = attribute;
-                    switch(pathAdd.getEntryKind()) {
-                        case IClasspathEntry.CPE_LIBRARY:
-                            pathAdd = JavaCore.newLibraryEntry(pathAdd.getPath(),
-                                    pathAdd.getSourceAttachmentPath(), 
-                                    pathAdd.getSourceAttachmentRootPath(),
-                                    pathAdd.getAccessRules(), newattrib, 
-                                    pathAdd.isExported());
-                            break;
-                            
-                        case IClasspathEntry.CPE_VARIABLE:
-                            pathAdd = JavaCore.newVariableEntry(pathAdd.getPath(),
-                                    pathAdd.getSourceAttachmentPath(), 
-                                    pathAdd.getSourceAttachmentRootPath(),
-                                    pathAdd.getAccessRules(), newattrib, 
-                                    pathAdd.isExported());
-                            break;
-    
-                        case IClasspathEntry.CPE_CONTAINER:
-                            pathAdd = JavaCore.newContainerEntry(pathAdd.getPath(),
-                                    pathAdd.getAccessRules(), newattrib, 
-                                    pathAdd.isExported());
-                            break;
-                            
-                        case IClasspathEntry.CPE_PROJECT:
-                            pathAdd = JavaCore.newProjectEntry(pathAdd.getPath(), 
-                                    pathAdd.getAccessRules(), 
-                                    true, newattrib, pathAdd.isExported());
-                            break;
-                    }
-                    
-                    cp[cpIndex] = pathAdd;
-                    jp.setRawClasspath(cp, null);
-                }
-    		} else {
-    			addEntryToJavaBuildPath(jp, attribute, jarPath, eKind);
-    		}
-    	} catch (JavaModelException e) {
-    	}
-    }
+	private static boolean shouldCheckOldStylePath(IProject project, String pathKind) {
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		return projectNode.get(pathKind, "").length() == 0 && projectNode.get(pathKind + "1", "").length() > 0;
+	}
 
-    private static String[] internalGetProjectPath(IProject project, IClasspathAttribute attribute, boolean useResolvedPath) {
-        if (isAspectPathAttribute(attribute)) {
-            if (shouldCheckOldStylePath(project, ASPECTPATH)) {
-        		String[] old = getOldProjectPath(project, true);
-        		if (old != null) {
-        			AJLog.log("Migrating aspect path settings for project "+project.getName()); //$NON-NLS-1$
-        			setProjectAspectPath(project,old[0],old[1],old[2]);
-        		}
-        		markOldStylePathAsRead(project, ASPECTPATH);
-            }
-        } else { // INPATH_ATTRIBUTE
-            if (shouldCheckOldStylePath(project, INPATH)) {
-                String[] old = getOldProjectPath(project, false);
-                if (old != null) {
-                    AJLog.log("Migrating aspect path settings for project "+project.getName()); //$NON-NLS-1$
-                    setProjectInPath(project,old[0],old[1],old[2]);
-                }
-                markOldStylePathAsRead(project, INPATH);
-            }
-        }
-    	String pathString = ""; //$NON-NLS-1$
-    	String contentString = ""; //$NON-NLS-1$
-    	String entryString = ""; //$NON-NLS-1$
-    
-    	IJavaProject javaProject = JavaCore.create(project);
-    	try {
-            IClasspathEntry[] cp = javaProject.getRawClasspath();
-    		for (int i = 0; i < cp.length; i++) {
-    			IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
-    			boolean attributeFound = false;
-    			for (int j = 0; j < attributes.length; j++) {
-    				if (attributes[j].getName().equals(attribute.getName())) {
-    				    attributeFound = true;
-    				    List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
-    				    
-    				    if (useResolvedPath) {
-    				        // this entry is on the path.  must resolve it
-    				        if (cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
-    				            List<IClasspathEntry>containerEntries = resolveClasspathContainer(cp[i], project);
-    				            // Bug 273770 - look for the XXXPATH_RESTRICTION_ATTRIBUTE_NAME classpath attribute
-    				            Set<String> extraPathElements = findContainerRestrictions(cp[i], isAspectPathAttribute(attribute));
-    				            if (extraPathElements != null && extraPathElements.size() > 0) {
-    				                // must filter
-    				                for (Iterator<IClasspathEntry> cpIter = containerEntries.iterator(); cpIter.hasNext(); ) {
-    				                    IClasspathEntry containerEntry = cpIter.next();
-    				                    if (!containsAsPathFragment(extraPathElements, containerEntry)) {
-    				                        cpIter.remove();
-    				                    }
-    				                }
-    				            }
-    				            actualEntries.addAll(containerEntries);
-    				        } else if (cp[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {
-    				            IProject requiredProj = project.getWorkspace().getRoot().getProject(
-    				                    cp[i].getPath().makeRelative().toPortableString());
-    				            if (! requiredProj.getName().equals(project.getName())   
-    				                    && requiredProj.exists()) {
-    					            actualEntries.addAll(resolveDependentProjectClasspath(cp[i], requiredProj));
-    				            }
-    				        } else { // resolve the classpath variable
-    				        	IClasspathEntry resolved = JavaCore.getResolvedClasspathEntry(cp[i]);
-    				        	if (resolved != null) {
-        				        	if (resolved.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
-        				        		// must resolve the project
-        				        		actualEntries.addAll(resolveDependentProjectClasspath(resolved, project.getWorkspace().getRoot().getProject(resolved.getPath().toString())));
-        				        	} else {
-        				        		actualEntries.add(resolved);
-        				        	}
-    				        	}
-    				        } // cp[i].getEntryKind()
-    				    } else {
-    				        actualEntries.add(cp[i]);
-    				    } // useResolvedEntry
-    				    
-    				    for (IClasspathEntry actualEntry : actualEntries) {
-    				        // we can get null for actualEntry if the raw entry corresponds to 
-    				        // an unbound classpath variable
-    				        if (actualEntry != null) {
-    	                        pathString += actualEntry.getPath().toPortableString() + File.pathSeparator;
-    	                        contentString += actualEntry.getContentKind() + File.pathSeparator;
-    	                        entryString += actualEntry.getEntryKind() + File.pathSeparator;
-    				        }
-    				    }
-    				}  // attributes[j].equals(attribute)
-    			}  // for (int j = 0; j < attributes.length; j++)
-    			
-    			// there is a special case that we must look inside the classpath container for entries with
-    			// attributes if we are returning the resolved path and the container itself isn't already
-    			// on the path.
-    			if (!attributeFound && useResolvedPath && cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
-    			    List<IClasspathEntry> containerEntries = resolveClasspathContainer(cp[i], project);
-    			    
-    			    for (IClasspathEntry containerEntry : containerEntries) {
-    			        if (isOnPath(containerEntry, isAspectPathAttribute(attribute))) {
-    			            pathString += containerEntry.getPath().toPortableString() + File.pathSeparator;
-    			            contentString += containerEntry.getContentKind() + File.pathSeparator;
-    			            entryString += containerEntry.getEntryKind() + File.pathSeparator;
-    			        }
-    			    }  // for (Iterator cpIter = containerEntries.iterator(); cpIter.hasNext(); ) 
-    			}  // !attributeFound && useResolvedPath && cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER
-    		}  // for (int i = 0; i < cp.length; i++)
-    	} catch (JavaModelException e) {
-    	}
-    	return new String[] { pathString, contentString, entryString };
-    }
+	private static void markOldStylePathAsRead(IProject project, String pathKind) {
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		projectNode.put(pathKind, "visited");
+		try {
+			projectNode.flush();
+		} catch (BackingStoreException e) {
+		}
+	}
 
-    public static boolean containsAsPathFragment(Set<String> extraPathElements,
-            IClasspathEntry containerEntry) {
-        if (extraPathElements.size() == 0) {
-            return false;
-        }
-        String pathStr = containerEntry.getPath().toString();
-        for (String extraPathStr : extraPathElements) {
-            if (pathStr.indexOf(extraPathStr) != -1) {
-                return true;
-            }
-        }
-        return false;
-    }
+	private static String[] getOldProjectPath(IProject project, boolean aspectPath) {
+		String pathName;
+		String pathConKinds;
+		String pathEntKinds;
+		if (aspectPath) {
+			pathName = ASPECTPATH;
+			pathConKinds = ASPECTPATH_CON_KINDS;
+			pathEntKinds = ASPECTPATH_ENT_KINDS;
+		} else {
+			pathName = INPATH;
+			pathConKinds = INPATH_CON_KINDS;
+			pathEntKinds = INPATH_ENT_KINDS;
+		}
 
-    private static Set<String> findContainerRestrictions(IClasspathEntry containerEntry,
-            boolean isAspectPathAttribute) {
-        if (containerEntry.getEntryKind() != IClasspathEntry.CPE_CONTAINER) {
-            return Collections.emptySet();
-        }
-        Set<String> restrictionPaths = new HashSet<String>();
-        String restrictions = getRestriction(containerEntry, 
-                isAspectPathAttribute ? ASPECTPATH_RESTRICTION_ATTRIBUTE_NAME : INPATH_RESTRICTION_ATTRIBUTE_NAME);
-        if (restrictions != null) {
-            String[] restrictionsArr = restrictions.split(",");
-            for (int j = 0; j < restrictionsArr.length; j++) {
-                restrictionPaths.add(restrictionsArr[j].trim());
-            }
-            return restrictionPaths;
-        } else {
-            return null;
-        }
-    }
+		IScopeContext projectScope = new ProjectScope(project);
+		IEclipsePreferences projectNode = projectScope.getNode(AspectJPlugin.UI_PLUGIN_ID);
+		String pathString = ""; //$NON-NLS-1$
+		int index = 1;
+		String value = projectNode.get(pathName + index, ""); //$NON-NLS-1$
+		if (value.length() == 0) {
+			return null;
+		}
+		while (value.length() > 0) {
+			pathString += value;
+			pathString += File.pathSeparator;
+			index++;
+			value = projectNode.get(pathName + index, ""); //$NON-NLS-1$
+		}
 
-    private static void addAttribute(IJavaProject jp, IClasspathEntry entry, IClasspathAttribute attr) {
-    	try {
-    		IClasspathEntry[] cp = jp.getRawClasspath();
-    		for (int i = 0; i < cp.length; i++) {
-    			if (cp[i].equals(entry)) {
-    				IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
-    				IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length + 1];
-    				System.arraycopy(attributes, 0, newattrib, 0, attributes.length);
-    				newattrib[attributes.length] = attr;
-    				switch (cp[i].getEntryKind()) {
-                        case IClasspathEntry.CPE_LIBRARY:
-                            cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), 
-                                    cp[i].getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
-    
-                        case IClasspathEntry.CPE_VARIABLE:
-                            cp[i] = JavaCore.newVariableEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), 
-                                    cp[i].getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
-    
-                        case IClasspathEntry.CPE_CONTAINER:
-                            cp[i] = JavaCore.newContainerEntry(cp[i].getPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
-    
-                        case IClasspathEntry.CPE_PROJECT:
-                            cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), 
-                                    cp[i].getAccessRules(), true, newattrib,
-                                    cp[i].isExported());
-                            break;
-    
-                    }
-    			}
-    		}
-    		jp.setRawClasspath(cp, null);
-    	} catch (JavaModelException e) {
-    	}
-    }
+		String contentString = ""; //$NON-NLS-1$
+		index = 1;
+		value = projectNode.get(pathConKinds + index, ""); //$NON-NLS-1$
+		while (value.length() > 0) {
+			contentString += toContentKind(value.toUpperCase());
+			contentString += File.pathSeparator;
+			index++;
+			value = projectNode.get(pathConKinds + index, ""); //$NON-NLS-1$
+		}
 
-    public static void removeAttribute(IJavaProject jp, IClasspathEntry entry, IClasspathAttribute attr) {
-    	try {
-    		IClasspathEntry[] cp = jp.getRawClasspath();
-    		for (int i = 0; i < cp.length; i++) {
-    			if (cp[i].equals(entry)) {
-    				IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
-    				IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length - 1];
-    				int count = 0;
-    				for (int j = 0; j < attributes.length; j++) {
-    					if (!attributes[j].getName().equals(attr.getName())) {
-    						newattrib[count++] = attributes[j];
-    					}
-    				}
-                    switch(cp[i].getEntryKind()) {
-                        case IClasspathEntry.CPE_LIBRARY:
-                            cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), cp[i]
-                                            .getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, cp[i]
-                                            .isExported());
-                            break;
-                            
-                        case IClasspathEntry.CPE_VARIABLE:
-                            cp[i] = JavaCore.newVariableEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), cp[i]
-                                            .getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, cp[i]
-                                            .isExported());                     
-                            break;
-    
-                        case IClasspathEntry.CPE_CONTAINER:
-                            cp[i] = JavaCore.newContainerEntry(cp[i].getPath(),
-                                    cp[i].getAccessRules(), newattrib, cp[i]
-                                            .isExported());                     
-                            break;
-                            
-                        case IClasspathEntry.CPE_PROJECT:
-                            cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), 
-                                    cp[i].getAccessRules(), 
-                                    true, newattrib, cp[i].isExported());
-                            break;
-                    }
-    			}
-    		}
-    		jp.setRawClasspath(cp, null);
-    	} catch (JavaModelException e) {
-    	}
-    }
+		String entryString = ""; //$NON-NLS-1$
+		index = 1;
+		value = projectNode.get(pathEntKinds + index, ""); //$NON-NLS-1$
+		while (value.length() > 0) {
+			entryString += toEntryKind(value.toUpperCase());
+			entryString += File.pathSeparator;
+			index++;
+			value = projectNode.get(pathEntKinds + index, ""); //$NON-NLS-1$
+		}
+		return new String[] { pathString, contentString, entryString };
+	}
 
-    /**
+	/**
+	 * Firstly, add library to the Java build path if it's not there already,
+	 * then mark the entry as being on the aspect path
+	 * 
+	 * @param project
+	 * @param path
+	 */
+	private static void addAttribute(IProject project, String jarPath, int eKind, IClasspathAttribute attribute) {
+		IJavaProject jp = JavaCore.create(project);
+
+		try {
+			IClasspathEntry[] cp = jp.getRawClasspath();
+			int cpIndex = getIndexInBuildPathEntry(cp, jarPath);
+			if (cpIndex >= 0) { // already on classpath
+				// add attribute to classpath entry
+				// if it doesn't already exist
+				IClasspathEntry pathAdd = cp[cpIndex];
+				// only add attribute if this element is not already on the path
+				if (isAspectPathAttribute(attribute) ? !isOnAspectpath(pathAdd) : !isOnInpath(pathAdd)) {
+					IClasspathAttribute[] attributes = pathAdd.getExtraAttributes();
+					IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length + 1];
+					System.arraycopy(attributes, 0, newattrib, 0, attributes.length);
+					newattrib[attributes.length] = attribute;
+					switch (pathAdd.getEntryKind()) {
+					case IClasspathEntry.CPE_LIBRARY:
+						pathAdd = JavaCore.newLibraryEntry(pathAdd.getPath(), pathAdd.getSourceAttachmentPath(),
+								pathAdd.getSourceAttachmentRootPath(), pathAdd.getAccessRules(), newattrib,
+								pathAdd.isExported());
+						break;
+
+					case IClasspathEntry.CPE_VARIABLE:
+						pathAdd = JavaCore.newVariableEntry(pathAdd.getPath(), pathAdd.getSourceAttachmentPath(),
+								pathAdd.getSourceAttachmentRootPath(), pathAdd.getAccessRules(), newattrib,
+								pathAdd.isExported());
+						break;
+
+					case IClasspathEntry.CPE_CONTAINER:
+						pathAdd = JavaCore.newContainerEntry(pathAdd.getPath(), pathAdd.getAccessRules(), newattrib,
+								pathAdd.isExported());
+						break;
+
+					case IClasspathEntry.CPE_PROJECT:
+						pathAdd = JavaCore.newProjectEntry(pathAdd.getPath(), pathAdd.getAccessRules(), true, newattrib,
+								pathAdd.isExported());
+						break;
+					}
+
+					cp[cpIndex] = pathAdd;
+					jp.setRawClasspath(cp, null);
+				}
+			} else {
+				addEntryToJavaBuildPath(jp, attribute, jarPath, eKind);
+			}
+		} catch (JavaModelException e) {
+		}
+	}
+
+	private static String[] internalGetProjectPath(IProject project, IClasspathAttribute attribute,
+			boolean useResolvedPath) {
+		if (isAspectPathAttribute(attribute)) {
+			if (shouldCheckOldStylePath(project, ASPECTPATH)) {
+				String[] old = getOldProjectPath(project, true);
+				if (old != null) {
+					AJLog.log("Migrating aspect path settings for project " + project.getName()); //$NON-NLS-1$
+					setProjectAspectPath(project, old[0], old[1], old[2]);
+				}
+				markOldStylePathAsRead(project, ASPECTPATH);
+			}
+		} else { // INPATH_ATTRIBUTE
+			if (shouldCheckOldStylePath(project, INPATH)) {
+				String[] old = getOldProjectPath(project, false);
+				if (old != null) {
+					AJLog.log("Migrating aspect path settings for project " + project.getName()); //$NON-NLS-1$
+					setProjectInPath(project, old[0], old[1], old[2]);
+				}
+				markOldStylePathAsRead(project, INPATH);
+			}
+		}
+		String pathString = ""; //$NON-NLS-1$
+		String contentString = ""; //$NON-NLS-1$
+		String entryString = ""; //$NON-NLS-1$
+
+		IJavaProject javaProject = JavaCore.create(project);
+		try {
+			IClasspathEntry[] cp = javaProject.getRawClasspath();
+			AJLog.log("internalGetProjectPath: iterating over classpath entries, size #"+(cp==null?0:cp.length));
+			for (int i = 0; i < cp.length; i++) {
+				IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
+				AJLog.log("internalGetProjectPath: attributes on "+cp[i].getPath()+" are "+toString(attributes));
+				boolean attributeFound = false;
+				for (int j = 0; j < attributes.length; j++) {
+					if (attributes[j].getName().equals(attribute.getName())) {
+						attributeFound = true;
+						List<IClasspathEntry> actualEntries = new ArrayList<IClasspathEntry>();
+
+						if (useResolvedPath) {
+							// this entry is on the path. must resolve it
+							if (cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
+								List<IClasspathEntry> containerEntries = resolveClasspathContainer(cp[i], project);
+								// Bug 273770 - look for the
+								// XXXPATH_RESTRICTION_ATTRIBUTE_NAME classpath
+								// attribute
+								Set<String> extraPathElements = findContainerRestrictions(cp[i],
+										isAspectPathAttribute(attribute));
+								if (extraPathElements != null && extraPathElements.size() > 0) {
+									// must filter
+									for (Iterator<IClasspathEntry> cpIter = containerEntries.iterator(); cpIter
+											.hasNext();) {
+										IClasspathEntry containerEntry = cpIter.next();
+										if (!containsAsPathFragment(extraPathElements, containerEntry)) {
+											cpIter.remove();
+										}
+									}
+								}
+								actualEntries.addAll(containerEntries);
+							} else if (cp[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {
+								IProject requiredProj = project.getWorkspace().getRoot()
+										.getProject(cp[i].getPath().makeRelative().toPortableString());
+								if (!requiredProj.getName().equals(project.getName()) && requiredProj.exists()) {
+									actualEntries.addAll(resolveDependentProjectClasspath(cp[i], requiredProj));
+								}
+							} else { // resolve the classpath variable
+								IClasspathEntry resolved = JavaCore.getResolvedClasspathEntry(cp[i]);
+								if (resolved != null) {
+									if (resolved.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
+										// must resolve the project
+										actualEntries.addAll(resolveDependentProjectClasspath(resolved, project
+												.getWorkspace().getRoot().getProject(resolved.getPath().toString())));
+									} else {
+										actualEntries.add(resolved);
+									}
+								}
+							} // cp[i].getEntryKind()
+						} else {
+							actualEntries.add(cp[i]);
+						} // useResolvedEntry
+
+						for (IClasspathEntry actualEntry : actualEntries) {
+							// we can get null for actualEntry if the raw entry
+							// corresponds to
+							// an unbound classpath variable
+							if (actualEntry != null) {
+								pathString += actualEntry.getPath().toPortableString() + File.pathSeparator;
+								contentString += actualEntry.getContentKind() + File.pathSeparator;
+								entryString += actualEntry.getEntryKind() + File.pathSeparator;
+							}
+						}
+					} // attributes[j].equals(attribute)
+				} // for (int j = 0; j < attributes.length; j++)
+
+				// there is a special case that we must look inside the
+				// classpath container for entries with
+				// attributes if we are returning the resolved path and the
+				// container itself isn't already
+				// on the path.
+				if (!attributeFound && useResolvedPath && cp[i].getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
+					List<IClasspathEntry> containerEntries = resolveClasspathContainer(cp[i], project);
+
+					for (IClasspathEntry containerEntry : containerEntries) {
+						if (isOnPath(containerEntry, isAspectPathAttribute(attribute))) {
+							pathString += containerEntry.getPath().toPortableString() + File.pathSeparator;
+							contentString += containerEntry.getContentKind() + File.pathSeparator;
+							entryString += containerEntry.getEntryKind() + File.pathSeparator;
+						}
+					} // for (Iterator cpIter = containerEntries.iterator();
+						// cpIter.hasNext(); )
+				} // !attributeFound && useResolvedPath && cp[i].getEntryKind()
+					// == IClasspathEntry.CPE_CONTAINER
+			} // for (int i = 0; i < cp.length; i++)
+		} catch (JavaModelException e) {
+		}
+		return new String[] { pathString, contentString, entryString };
+	}
+
+	private static String toString(IClasspathAttribute[] attributes) {
+		StringBuilder s = new StringBuilder();
+		if (attributes != null) {
+			for (IClasspathAttribute ca: attributes) {
+				s.append(ca.getName()+"="+ca.getValue()+" ");
+			}
+		}
+		return s.toString().trim();
+	}
+
+	public static boolean containsAsPathFragment(Set<String> extraPathElements, IClasspathEntry containerEntry) {
+		if (extraPathElements.size() == 0) {
+			return false;
+		}
+		String pathStr = containerEntry.getPath().toString();
+		for (String extraPathStr : extraPathElements) {
+			if (pathStr.indexOf(extraPathStr) != -1) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private static Set<String> findContainerRestrictions(IClasspathEntry containerEntry,
+			boolean isAspectPathAttribute) {
+		if (containerEntry.getEntryKind() != IClasspathEntry.CPE_CONTAINER) {
+			return Collections.emptySet();
+		}
+		Set<String> restrictionPaths = new HashSet<String>();
+		String restrictions = getRestriction(containerEntry,
+				isAspectPathAttribute ? ASPECTPATH_RESTRICTION_ATTRIBUTE_NAME : INPATH_RESTRICTION_ATTRIBUTE_NAME);
+		if (restrictions != null) {
+			String[] restrictionsArr = restrictions.split(",");
+			for (int j = 0; j < restrictionsArr.length; j++) {
+				restrictionPaths.add(restrictionsArr[j].trim());
+			}
+			return restrictionPaths;
+		} else {
+			return null;
+		}
+	}
+
+	private static void addAttribute(IJavaProject jp, IClasspathEntry entry, IClasspathAttribute attr) {
+		try {
+			IClasspathEntry[] cp = jp.getRawClasspath();
+			for (int i = 0; i < cp.length; i++) {
+				if (cp[i].equals(entry)) {
+					IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
+					IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length + 1];
+					System.arraycopy(attributes, 0, newattrib, 0, attributes.length);
+					newattrib[attributes.length] = attr;
+					switch (cp[i].getEntryKind()) {
+					case IClasspathEntry.CPE_LIBRARY:
+						cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_VARIABLE:
+						cp[i] = JavaCore.newVariableEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_CONTAINER:
+						cp[i] = JavaCore.newContainerEntry(cp[i].getPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_PROJECT:
+						cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), cp[i].getAccessRules(), true, newattrib,
+								cp[i].isExported());
+						break;
+
+					}
+				}
+			}
+			jp.setRawClasspath(cp, null);
+		} catch (JavaModelException e) {
+		}
+	}
+
+	public static void removeAttribute(IJavaProject jp, IClasspathEntry entry, IClasspathAttribute attr) {
+		try {
+			IClasspathEntry[] cp = jp.getRawClasspath();
+			for (int i = 0; i < cp.length; i++) {
+				if (cp[i].equals(entry)) {
+					IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
+					IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length - 1];
+					int count = 0;
+					for (int j = 0; j < attributes.length; j++) {
+						if (!attributes[j].getName().equals(attr.getName())) {
+							newattrib[count++] = attributes[j];
+						}
+					}
+					switch (cp[i].getEntryKind()) {
+					case IClasspathEntry.CPE_LIBRARY:
+						cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_VARIABLE:
+						cp[i] = JavaCore.newVariableEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_CONTAINER:
+						cp[i] = JavaCore.newContainerEntry(cp[i].getPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_PROJECT:
+						cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), cp[i].getAccessRules(), true, newattrib,
+								cp[i].isExported());
+						break;
+					}
+				}
+			}
+			jp.setRawClasspath(cp, null);
+		} catch (JavaModelException e) {
+		}
+	}
+
+	/**
 	 * Remove all occurrences of an attribute
+	 * 
 	 * @param javaProject
 	 * @param attribute
 	 */
-	private static void removeAttribute(IJavaProject javaProject,
-			IClasspathAttribute attribute) {
+	private static void removeAttribute(IJavaProject javaProject, IClasspathAttribute attribute) {
 		try {
 			IClasspathEntry[] cp = javaProject.getRawClasspath();
 			boolean changed = false;
 			for (int i = 0; i < cp.length; i++) {
-				IClasspathAttribute[] attributes = cp[i]
-						.getExtraAttributes();
+				IClasspathAttribute[] attributes = cp[i].getExtraAttributes();
 				boolean found = false;
 				for (int j = 0; !found && (j < attributes.length); j++) {
 					if (attributes[j].getName().equals(attribute.getName())) {
@@ -952,44 +938,37 @@
 					}
 				}
 				if (found) {
-				    changed = true;
+					changed = true;
 					IClasspathAttribute[] newattrib = new IClasspathAttribute[attributes.length - 1];
 					int count = 0;
 					for (int j = 0; j < attributes.length; j++) {
-						if (!attributes[j].getName()
-								.equals(attribute.getName())) {
+						if (!attributes[j].getName().equals(attribute.getName())) {
 							newattrib[count++] = attributes[j];
 						}
 					}
-                    switch(cp[i].getEntryKind()) {
-                        case IClasspathEntry.CPE_LIBRARY:
-                            cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), 
-                                    cp[i].getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
-                            
-                        case IClasspathEntry.CPE_VARIABLE:
-                            cp[i] = JavaCore.newVariableEntry(cp[i].getPath(),
-                                    cp[i].getSourceAttachmentPath(), 
-                                    cp[i].getSourceAttachmentRootPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
+					switch (cp[i].getEntryKind()) {
+					case IClasspathEntry.CPE_LIBRARY:
+						cp[i] = JavaCore.newLibraryEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
 
-                        case IClasspathEntry.CPE_CONTAINER:
-                            cp[i] = JavaCore.newContainerEntry(cp[i].getPath(),
-                                    cp[i].getAccessRules(), newattrib, 
-                                    cp[i].isExported());
-                            break;
-                            
-                        case IClasspathEntry.CPE_PROJECT:
-                            cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), 
-                                    cp[i].getAccessRules(), 
-                                    true, newattrib, cp[i].isExported());
-                            break;
-                    }
+					case IClasspathEntry.CPE_VARIABLE:
+						cp[i] = JavaCore.newVariableEntry(cp[i].getPath(), cp[i].getSourceAttachmentPath(),
+								cp[i].getSourceAttachmentRootPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_CONTAINER:
+						cp[i] = JavaCore.newContainerEntry(cp[i].getPath(), cp[i].getAccessRules(), newattrib,
+								cp[i].isExported());
+						break;
+
+					case IClasspathEntry.CPE_PROJECT:
+						cp[i] = JavaCore.newProjectEntry(cp[i].getPath(), cp[i].getAccessRules(), true, newattrib,
+								cp[i].isExported());
+						break;
+					}
 				}
 			}
 			if (changed) {
@@ -998,38 +977,34 @@
 		} catch (JavaModelException e) {
 		}
 	}
-	
-	
+
 	private static int getIndexInBuildPathEntry(IClasspathEntry[] cp, String jarPath) {
-        for (int i = 0; i < cp.length; i++) {
-            String entry = cp[i].getPath().toPortableString();
-            if (entry.equals(jarPath)) {
-                return i;
-            }
-        }
-        return -1;
+		for (int i = 0; i < cp.length; i++) {
+			String entry = cp[i].getPath().toPortableString();
+			if (entry.equals(jarPath)) {
+				return i;
+			}
+		}
+		return -1;
 	}
-	
-	
-	private static void addEntryToJavaBuildPath(IJavaProject jp,
-			IClasspathAttribute attribute, String path, int eKind) {
+
+	private static void addEntryToJavaBuildPath(IJavaProject jp, IClasspathAttribute attribute, String path,
+			int eKind) {
 		IClasspathAttribute[] attributes = new IClasspathAttribute[] { attribute };
 		try {
 			IClasspathEntry[] originalCP = jp.getRawClasspath();
 			IClasspathEntry[] newCP = new IClasspathEntry[originalCP.length + 1];
 			IClasspathEntry cp = null;
 			if (eKind == IClasspathEntry.CPE_LIBRARY) {
-				cp = JavaCore.newLibraryEntry(
-						new Path(path), null, null, new IAccessRule[0], attributes, false);
+				cp = JavaCore.newLibraryEntry(new Path(path), null, null, new IAccessRule[0], attributes, false);
 			} else if (eKind == IClasspathEntry.CPE_VARIABLE) {
-				cp = JavaCore.newVariableEntry(
-						new Path(path), null, null, new IAccessRule[0], attributes, false);
+				cp = JavaCore.newVariableEntry(new Path(path), null, null, new IAccessRule[0], attributes, false);
 			} else if (eKind == IClasspathEntry.CPE_CONTAINER) {
-			    cp = JavaCore.newContainerEntry(new Path(path), null, attributes, false);
+				cp = JavaCore.newContainerEntry(new Path(path), null, attributes, false);
 			} else if (eKind == IClasspathEntry.CPE_PROJECT) {
-			    cp = JavaCore.newProjectEntry(new Path(path), null, true, attributes, false);
+				cp = JavaCore.newProjectEntry(new Path(path), null, true, attributes, false);
 			}
-			
+
 			// Update the raw classpath with the new entry.
 			if (cp != null) {
 				System.arraycopy(originalCP, 0, newCP, 0, originalCP.length);
@@ -1067,137 +1042,131 @@
 		return new Integer(entry).toString();
 	}
 
-    public static String getRestriction(IClasspathEntry pathEntry, String attributeName) {
-        IClasspathAttribute[] attributes = pathEntry.getExtraAttributes();
-        for (int i = 0; i < attributes.length; i++) {
-            IClasspathAttribute attribute = attributes[i];
-            if (attribute.getName().equals(attributeName)) {
-                String extraStr = attribute.getValue();
-                if (extraStr != null) {
-                    return extraStr;
-                }
-            }
-        }
+	public static String getRestriction(IClasspathEntry pathEntry, String attributeName) {
+		IClasspathAttribute[] attributes = pathEntry.getExtraAttributes();
+		for (int i = 0; i < attributes.length; i++) {
+			IClasspathAttribute attribute = attributes[i];
+			if (attribute.getName().equals(attributeName)) {
+				String extraStr = attribute.getValue();
+				if (extraStr != null) {
+					return extraStr;
+				}
+			}
+		}
 
-        return null;
-    }
-    
-    /**
-     * adds the classpath attribute to the entry with the default value if it doesn't already exist
-     * else does nothing
-     */
-    public static IClasspathEntry ensureHasAttribute(IClasspathEntry curr, String attributeName, String defaultVal) {
-        int index = indexOfAttribute(curr.getExtraAttributes(), attributeName);
-        if (index < 0) {
-            IClasspathAttribute[] attrs = curr.getExtraAttributes();
-            // must create a new entry with more extra attributes
-            IClasspathAttribute newAttr = JavaCore.newClasspathAttribute(attributeName, defaultVal);
-            IClasspathAttribute[] newAttrs;
-            if (attrs == null || attrs.length == 0) {
-                newAttrs = new IClasspathAttribute[] { newAttr };
-            } else {
-                newAttrs = new IClasspathAttribute[attrs.length+1];
-                System.arraycopy(attrs, 0, newAttrs, 0, attrs.length);
-                newAttrs[attrs.length] = newAttr;
-            }
-            return copyContainerEntry(curr, newAttrs);
-        } else {
-            return curr;
-        }
-    }
-    
-    /**
-     * adds the classpath attribute to the entry with the default value if it doesn't already exist
-     * else does nothing
-     */
-    public static IClasspathEntry ensureHasNoAttribute(IClasspathEntry curr, String attributeName) {
-        int index = indexOfAttribute(curr.getExtraAttributes(), attributeName);
-        if (index < 0) {
-            return curr;
-        } else {
-            IClasspathAttribute[] attrs = curr.getExtraAttributes();
-            // must create a new entry with more extra attributes
-            IClasspathAttribute[] newAttrs = new IClasspathAttribute[attrs.length-1];
-            for (int i = 0, j = 0; i < newAttrs.length; i++) {
-                if (i != index) {
-                    newAttrs[j] = attrs[i];
-                    j++;
-                }
-            }
-            return copyContainerEntry(curr, newAttrs);
-        }
-    }
-    
+		return null;
+	}
 
+	/**
+	 * adds the classpath attribute to the entry with the default value if it
+	 * doesn't already exist else does nothing
+	 */
+	public static IClasspathEntry ensureHasAttribute(IClasspathEntry curr, String attributeName, String defaultVal) {
+		int index = indexOfAttribute(curr.getExtraAttributes(), attributeName);
+		if (index < 0) {
+			IClasspathAttribute[] attrs = curr.getExtraAttributes();
+			// must create a new entry with more extra attributes
+			IClasspathAttribute newAttr = JavaCore.newClasspathAttribute(attributeName, defaultVal);
+			IClasspathAttribute[] newAttrs;
+			if (attrs == null || attrs.length == 0) {
+				newAttrs = new IClasspathAttribute[] { newAttr };
+			} else {
+				newAttrs = new IClasspathAttribute[attrs.length + 1];
+				System.arraycopy(attrs, 0, newAttrs, 0, attrs.length);
+				newAttrs[attrs.length] = newAttr;
+			}
+			return copyContainerEntry(curr, newAttrs);
+		} else {
+			return curr;
+		}
+	}
 
-    public static IClasspathEntry copyContainerEntry(IClasspathEntry containerEntry, 
-            IClasspathAttribute[] extraAttrs) {
-        return JavaCore.newContainerEntry(containerEntry.getPath(), 
-                containerEntry.getAccessRules(), extraAttrs, containerEntry.isExported());
-    }
-    
-    private static int indexOfAttribute(IClasspathAttribute[] attrs,
-            String attrName) {
-        for (int i = 0; i < attrs.length; i++) {
-            if (attrs[i].getName().equals(attrName)) {
-                return i;
-            }
-        }
-        return -1;
-    }
+	/**
+	 * adds the classpath attribute to the entry with the default value if it
+	 * doesn't already exist else does nothing
+	 */
+	public static IClasspathEntry ensureHasNoAttribute(IClasspathEntry curr, String attributeName) {
+		int index = indexOfAttribute(curr.getExtraAttributes(), attributeName);
+		if (index < 0) {
+			return curr;
+		} else {
+			IClasspathAttribute[] attrs = curr.getExtraAttributes();
+			// must create a new entry with more extra attributes
+			IClasspathAttribute[] newAttrs = new IClasspathAttribute[attrs.length - 1];
+			for (int i = 0, j = 0; i < newAttrs.length; i++) {
+				if (i != index) {
+					newAttrs[j] = attrs[i];
+					j++;
+				}
+			}
+			return copyContainerEntry(curr, newAttrs);
+		}
+	}
 
+	public static IClasspathEntry copyContainerEntry(IClasspathEntry containerEntry, IClasspathAttribute[] extraAttrs) {
+		return JavaCore.newContainerEntry(containerEntry.getPath(), containerEntry.getAccessRules(), extraAttrs,
+				containerEntry.isExported());
+	}
 
-    
-    /**
-     * Adds the classpath restriction to the given classpath entry.
-     * Returns the new classpath entry
-     */
-    public static IClasspathEntry updatePathRestrictions(IClasspathEntry entry,
-            String restrictionStr, String restrictionKind) {
-        IClasspathAttribute[] attrs = entry.getExtraAttributes();
-        int index = indexOfAttribute(attrs, restrictionKind);
-        IClasspathAttribute newAttr = JavaCore.newClasspathAttribute(restrictionKind, restrictionStr);
-        if (index >= 0) {
-            // just replace
-            attrs[index] = newAttr;
-        } else {
-            // must create a new entry with more extra attributes
-            IClasspathAttribute[] newAttrs;
-            if (attrs == null || attrs.length == 0) {
-                newAttrs = new IClasspathAttribute[] { newAttr };
-            } else {
-                newAttrs = new IClasspathAttribute[attrs.length+1];
-                System.arraycopy(attrs, 0, newAttrs, 0, attrs.length);
-                newAttrs[attrs.length] = newAttr;
-            }
-            entry = copyContainerEntry(entry, newAttrs);
-        }
-        return entry;
-    }
+	private static int indexOfAttribute(IClasspathAttribute[] attrs, String attrName) {
+		for (int i = 0; i < attrs.length; i++) {
+			if (attrs[i].getName().equals(attrName)) {
+				return i;
+			}
+		}
+		return -1;
+	}
 
-    /**
-     * If this classpath entry's path already exists on the classpath, then it is replaced
-     * else it is added
-     */
-    public static void updateClasspathEntry(IProject project, IClasspathEntry newEntry) {
-        IJavaProject jProject = JavaCore.create(project);
-        try {
-            IClasspathEntry[] entries = jProject.getRawClasspath();
-            for (int i = 0; i < entries.length; i++) {
-                IClasspathEntry entry = entries[i];
-                if (newEntry.getPath().equals(entry.getPath())) {
-                    entries[i] = newEntry;
-                    jProject.setRawClasspath(entries, null);
-                    return;
-                }
-            }
-            
-            // entry not found on classpath...add it
-            IClasspathEntry[] newEntries = new IClasspathEntry[entries.length + 1];
-            System.arraycopy(entries, 0, newEntries, 0, entries.length);
-            newEntries[entries.length] = newEntry;
-            jProject.setRawClasspath(newEntries, null);
-        } catch (JavaModelException e) {
-        }
-    }
+	/**
+	 * Adds the classpath restriction to the given classpath entry. Returns the
+	 * new classpath entry
+	 */
+	public static IClasspathEntry updatePathRestrictions(IClasspathEntry entry, String restrictionStr,
+			String restrictionKind) {
+		IClasspathAttribute[] attrs = entry.getExtraAttributes();
+		int index = indexOfAttribute(attrs, restrictionKind);
+		IClasspathAttribute newAttr = JavaCore.newClasspathAttribute(restrictionKind, restrictionStr);
+		if (index >= 0) {
+			// just replace
+			attrs[index] = newAttr;
+		} else {
+			// must create a new entry with more extra attributes
+			IClasspathAttribute[] newAttrs;
+			if (attrs == null || attrs.length == 0) {
+				newAttrs = new IClasspathAttribute[] { newAttr };
+			} else {
+				newAttrs = new IClasspathAttribute[attrs.length + 1];
+				System.arraycopy(attrs, 0, newAttrs, 0, attrs.length);
+				newAttrs[attrs.length] = newAttr;
+			}
+			entry = copyContainerEntry(entry, newAttrs);
+		}
+		return entry;
+	}
+
+	/**
+	 * If this classpath entry's path already exists on the classpath, then it
+	 * is replaced else it is added
+	 */
+	public static void updateClasspathEntry(IProject project, IClasspathEntry newEntry) {
+		IJavaProject jProject = JavaCore.create(project);
+		try {
+			IClasspathEntry[] entries = jProject.getRawClasspath();
+			for (int i = 0; i < entries.length; i++) {
+				IClasspathEntry entry = entries[i];
+				if (newEntry.getPath().equals(entry.getPath())) {
+					entries[i] = newEntry;
+					jProject.setRawClasspath(entries, null);
+					return;
+				}
+			}
+
+			// entry not found on classpath...add it
+			IClasspathEntry[] newEntries = new IClasspathEntry[entries.length + 1];
+			System.arraycopy(entries, 0, newEntries, 0, entries.length);
+			newEntries[entries.length] = newEntry;
+			jProject.setRawClasspath(newEntries, null);
+		} catch (JavaModelException e) {
+		}
+	}
 }