Attachment #85276 for bug #212769

Lines 1849-1854 Link Here

(-)model/org/eclipse/jdt/internal/core/DeltaProcessor.java (+6 lines)
1849	this.currentDelta = null;	1849	this.currentDelta = null;
1850	}	1850	}
1851		1851
		1852	// add late coming elements to refresh (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
		1853	if (elementsToRefresh == null)
		1854	elementsToRefresh = this.state.removeExternalElementsToRefresh();
		1855	else
		1856	elementsToRefresh.addAll(this.state.removeExternalElementsToRefresh());
		1857
1852	// generate external archive change deltas	1858	// generate external archive change deltas
1853	if (elementsToRefresh != null) {	1859	if (elementsToRefresh != null) {
1854	createExternalArchiveDelta(elementsToRefresh, null);	1860	createExternalArchiveDelta(elementsToRefresh, null);

Lines 10-21 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathChange.java (+26 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core;	11	package org.eclipse.jdt.internal.core;
12		12
		13	import java.io.File;
		14	import java.net.URI;
13	import java.util.ArrayList;	15	import java.util.ArrayList;
14	import java.util.HashMap;	16	import java.util.HashMap;
15	import java.util.HashSet;	17	import java.util.HashSet;
16	import java.util.Iterator;	18	import java.util.Iterator;
17	import java.util.Map;	19	import java.util.Map;
18		20
		21	import org.eclipse.core.filesystem.EFS;
		22	import org.eclipse.core.filesystem.IFileStore;
19	import org.eclipse.core.resources.IFolder;	23	import org.eclipse.core.resources.IFolder;
20	import org.eclipse.core.resources.IResource;	24	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.resources.IWorkspace;	25	import org.eclipse.core.resources.IWorkspace;
Lines 261-266 Link Here
261		265
262	delta.changed(this.project, IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED);	266	delta.changed(this.project, IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED);
263	result \|= HAS_DELTA;	267	result \|= HAS_DELTA;
		268
		269	state.addForRefresh(this.project); // ensure external jars are refreshed for this project (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
264		270
265	Map removedRoots = null;	271	Map removedRoots = null;
266	IPackageFragmentRoot[] roots = null;	272	IPackageFragmentRoot[] roots = null;
Lines 314-319 Link Here
314	}	320	}
315	}	321	}
316	addClasspathDeltas(delta, pkgFragmentRoots, IJavaElementDelta.F_REMOVED_FROM_CLASSPATH);	322	addClasspathDeltas(delta, pkgFragmentRoots, IJavaElementDelta.F_REMOVED_FROM_CLASSPATH);
		323
		324	// remember timestamp of jars that were removed (in case they are added as external jar in the same operation)
		325	for (int j = 0, length = pkgFragmentRoots.length; j < length; j++) {
		326	IPackageFragmentRoot root = pkgFragmentRoots[j];
		327	if (root.isArchive() && !root.isExternal()) {
		328	URI location = root.getResource().getLocationURI();
		329	File file = null;
		330	try {
		331	IFileStore fileStore = EFS.getStore(location);
		332	file = fileStore.toLocalFile(EFS.NONE, null);
		333	} catch (CoreException e) {
		334	// continue
		335	}
		336	if (file == null)
		337	continue;
		338	long timeStamp = DeltaProcessor.getTimeStamp(file);
		339	IPath externalPath = new org.eclipse.core.runtime.Path(file.getAbsolutePath());
		340	state.getExternalLibTimeStamps().put(externalPath, new Long(timeStamp));
		341	}
		342	}
317	} else {	343	} else {
318	// remote project changes	344	// remote project changes
319	if (this.oldResolvedClasspath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {	345	if (this.oldResolvedClasspath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT) {




		this.stopDeltas();
	}
}
/*
 * Ensures that the correct delta is reported after a setRawClasspath and after a modification of an external jar.
 * (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
 */
public void testExternalJarChanged6() throws CoreException, IOException {
	File f = null;
	try {
		IJavaProject project = this.createJavaProject("P", new String[] {""}, "");
		
		String pPath = getExternalPath() + "p.jar";
		setClasspath(project, new IClasspathEntry[]{JavaCore.newLibraryEntry(new Path(pPath), null, null)});
		
		f = new File(pPath);
		f.createNewFile();
		getJavaModel().refreshExternalArchives(null,null);
		waitUntilIndexesReady();
		startDeltas();
		
		touch(f);
		setClasspath(project, new IClasspathEntry[]{JavaCore.newLibraryEntry(new Path(pPath), null, null), JavaCore.newSourceEntry(new Path("/P"))});
		
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	<project root>[*]: {ADDED TO CLASSPATH}\n" + 
			"	"+f.getCanonicalPath()+"[*]: {CONTENT | ARCHIVE CONTENT CHANGED}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		if(f != null) {
			deleteFile(f);
		}
		this.deleteProject("P");
		this.stopDeltas();
	}
}
/**
 * Refresh the JavaModel after an addition of an external jar.
 */




	assertEquals("Unexpected number of roots for non existing entry", 0, roots.length);

}
/*
 * Ensures that a type can be found if run after setting the classpath in a runnable
 * (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
 */
public void testFindTypeAfterSetClasspath() throws CoreException {
	try {
		final IJavaProject project = createJavaProject("P", new String[] {"src1"}, "bin");
		createFolder("/P/src2/p");
		createFile("/P/src2/p/X.java", "package p; public class X {}");
		project.findType("p.X"); // populate project's cache
		final IType[] result = new IType[1];
		ResourcesPlugin.getWorkspace().run(
			new IWorkspaceRunnable() {
				public void run(IProgressMonitor monitor) throws CoreException {
					addClasspathEntry(project, JavaCore.newSourceEntry(new Path("/P/src2")));
					result[0] = project.findType("p.X");
				}
			},
			null);
		assertElementsEqual(
			"Unexpected type found",
			"X [in X.java [in p [in src2 [in P]]]]",
			result);
	} finally {
		deleteProject("P");
	}
}
/**
 * Test that a folder with a dot name does not relate to a package fragment
 */

Return to bug 212769

Lines 389-394 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaProjectTests.java (+27 lines)
389	assertEquals("Unexpected number of roots for non existing entry", 0, roots.length);	389	assertEquals("Unexpected number of roots for non existing entry", 0, roots.length);
390		390
391	}	391	}
		392	/*
		393	* Ensures that a type can be found if run after setting the classpath in a runnable
		394	* (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
		395	*/
		396	public void testFindTypeAfterSetClasspath() throws CoreException {
		397	try {
		398	final IJavaProject project = createJavaProject("P", new String[] {"src1"}, "bin");
		399	createFolder("/P/src2/p");
		400	createFile("/P/src2/p/X.java", "package p; public class X {}");
		401	project.findType("p.X"); // populate project's cache
		402	final IType[] result = new IType[1];
		403	ResourcesPlugin.getWorkspace().run(
		404	new IWorkspaceRunnable() {
		405	public void run(IProgressMonitor monitor) throws CoreException {
		406	addClasspathEntry(project, JavaCore.newSourceEntry(new Path("/P/src2")));
		407	result[0] = project.findType("p.X");
		408	}
		409	},
		410	null);
		411	assertElementsEqual(
		412	"Unexpected type found",
		413	"X [in X.java [in p [in src2 [in P]]]]",
		414	result);
		415	} finally {
		416	deleteProject("P");
		417	}
		418	}
392	/**	419	/**
393	* Test that a folder with a dot name does not relate to a package fragment	420	* Test that a folder with a dot name does not relate to a package fragment
394	*/	421	*/

Lines 40-45 Link Here

(-)model/org/eclipse/jdt/internal/core/ChangeClasspathOperation.java (+5 lines)
40	* - create resolved classpath markers	40	* - create resolved classpath markers
41	*/	41	*/
42	protected void classpathChanged(JavaProject project) throws JavaModelException {	42	protected void classpathChanged(JavaProject project) throws JavaModelException {
		43	// reset the project's caches early since some clients rely on the project's caches being up-to-date when run inside an IWorkspaceRunnable
		44	// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769#c5 )
		45	project.resetCaches();
		46
43	DeltaProcessingState state = JavaModelManager.getDeltaState();	47	DeltaProcessingState state = JavaModelManager.getDeltaState();
44	DeltaProcessor deltaProcessor = state.getDeltaProcessor();	48	DeltaProcessor deltaProcessor = state.getDeltaProcessor();
45	ClasspathChange change = (ClasspathChange) deltaProcessor.classpathChanges.get(project.getProject());	49	ClasspathChange change = (ClasspathChange) deltaProcessor.classpathChanges.get(project.getProject());
Lines 55-60 Link Here
55	// however ensure project references are updated	59	// however ensure project references are updated
56	// since some clients rely on the project references when run inside an IWorkspaceRunnable	60	// since some clients rely on the project references when run inside an IWorkspaceRunnable
57	new ProjectReferenceChange(project, change.oldResolvedClasspath).updateProjectReferencesIfNecessary();	61	new ProjectReferenceChange(project, change.oldResolvedClasspath).updateProjectReferencesIfNecessary();
		62
58	} else {	63	} else {
59	JavaElementDelta delta = new JavaElementDelta(getJavaModel());	64	JavaElementDelta delta = new JavaElementDelta(getJavaModel());
60	int result = change.generateDelta(delta);	65	int result = change.generateDelta(delta);

Lines 270-275 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ExternalJarDeltaTests.java (+36 lines)
270	this.stopDeltas();	270	this.stopDeltas();
271	}	271	}
272	}	272	}
		273	/*
		274	* Ensures that the correct delta is reported after a setRawClasspath and after a modification of an external jar.
		275	* (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=212769 )
		276	*/
		277	public void testExternalJarChanged6() throws CoreException, IOException {
		278	File f = null;
		279	try {
		280	IJavaProject project = this.createJavaProject("P", new String[] {""}, "");
		281
		282	String pPath = getExternalPath() + "p.jar";
		283	setClasspath(project, new IClasspathEntry[]{JavaCore.newLibraryEntry(new Path(pPath), null, null)});
		284
		285	f = new File(pPath);
		286	f.createNewFile();
		287	getJavaModel().refreshExternalArchives(null,null);
		288	waitUntilIndexesReady();
		289	startDeltas();
		290
		291	touch(f);
		292	setClasspath(project, new IClasspathEntry[]{JavaCore.newLibraryEntry(new Path(pPath), null, null), JavaCore.newSourceEntry(new Path("/P"))});
		293
		294	assertDeltas(
		295	"Unexpected delta",
		296	"P[*]: {CHILDREN \| CONTENT \| RAW CLASSPATH CHANGED \| RESOLVED CLASSPATH CHANGED}\n" +
		297	" <project root>[*]: {ADDED TO CLASSPATH}\n" +
		298	" "+f.getCanonicalPath()+"[*]: {CONTENT \| ARCHIVE CONTENT CHANGED}\n" +
		299	" ResourceDelta(/P/.classpath)[*]"
		300	);
		301	} finally {
		302	if(f != null) {
		303	deleteFile(f);
		304	}
		305	this.deleteProject("P");
		306	this.stopDeltas();
		307	}
		308	}
273	/**	309	/**
274	* Refresh the JavaModel after an addition of an external jar.	310	* Refresh the JavaModel after an addition of an external jar.
275	*/	311	*/