Attachment #131061 for bug #233643




import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.builder.ReferenceCollection;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.jdt.internal.core.builder.StringSet;

	 * Incrementally builds using the {@link org.eclipse.pde.api.tools.internal.provisional.builder.IApiAnalyzer}
	 * from the given {@link ApiAnalysisBuilder}
	 * 
	 * @param baseline the baseline to compare with
	 * @param wbaseline the workspace baseline
	 * @param deltas the deltas to be built
	 * @param state the current JDT build state
	 * @param buildstate the current API tools build state
	 * @param monitor
	 * @throws CoreException
	 */
	public void build(IApiBaseline baseline, IApiBaseline wbaseline, IResourceDelta[] deltas, State state, BuildState buildstate, IProgressMonitor monitor) throws CoreException {
		IProject project = this.builder.getProject();
		SubMonitor localmonitor = SubMonitor.convert(monitor, NLS.bind(BuilderMessages.IncrementalBuilder_builder_for_project, project.getName()), 10);
		try {
			State state = (State)JavaModelManager.getJavaModelManager().getLastBuiltState(project, localmonitor.newChild(1));
			if(state == null) {
				this.builder.buildAll(baseline, localmonitor);
				return;
			}
			String[] projectNames = buildstate.getReexportedComponents();
			HashSet depprojects = null;
			if (projectNames.length != 0) {

			for (int i = 0; i < deltas.length; i++) {
				deltas[i].accept(visitor);
			}
			build(project, baseline, wbaseline, state, buildstate, localmonitor.newChild(1));
		}
		finally {
			if(!localmonitor.isCanceled()) {

	/**
	 * Builds an API delta using the default profile (from the workspace settings and the current
	 * @param project
	 * @param baseline the baseline to compare to
	 * @param wbaseline the current workspace baseline
	 * @param state the current JDT build state
	 * @param buildstate the current API tools build state
	 * @param monitor
	 */
	void build(final IProject project, IApiBaseline baseline, IApiBaseline wbaseline, final State state, BuildState buildstate, IProgressMonitor monitor) throws CoreException {
		IApiBaseline wsprofile = null;
		try {
			// clear the old state so a full build will occur if this one is cancelled or terminates prematurely
			this.builder.clearLastState();
			SubMonitor localmonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 1);
			collectAffectedSourceFiles(project, state, this.changedtypes);
			int typesize = this.changedtypes.size();

			if (typesize != 0) {
				IPluginModelBase currentModel = this.builder.getCurrentModel();
				if (currentModel != null) {
					wsprofile = this.builder.getWorkspaceProfile();
					if (wsprofile == null) {
						if (ApiAnalysisBuilder.DEBUG) {
							System.err.println("Could not retrieve a workspace profile"); //$NON-NLS-1$
						}
						return;
					}
					String id = currentModel.getBundleDescription().getSymbolicName();
					IApiComponent comp = wbaseline.getApiComponent(id);
					if(comp == null) {
						return;
					}

			}
		}
		finally {
			if(wsprofile != null) {
				wsprofile.close();
			}
			if(monitor != null) {
				monitor.done();
			}

Lines 488-494 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BaseApiAnalyzer.java (-1 / +1 lines)
488	return new BuildState();	488	return new BuildState();
489	}	489	}
490	try {	490	try {
491	BuildState state = ApiAnalysisBuilder.getLastBuiltState(project);	491	BuildState state = BuildState.getLastBuiltState(project);
492	if(state != null) {	492	if(state != null) {
493	return state;	493	return state;
494	}	494	}

Lines 10-17 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BuildState.java (-11 / +216 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.api.tools.internal.builder;	11	package org.eclipse.pde.api.tools.internal.builder;
12		12
		13	import java.io.BufferedInputStream;
		14	import java.io.BufferedOutputStream;
13	import java.io.DataInputStream;	15	import java.io.DataInputStream;
14	import java.io.DataOutputStream;	16	import java.io.DataOutputStream;
		17	import java.io.File;
		18	import java.io.FileInputStream;
		19	import java.io.FileOutputStream;
15	import java.io.IOException;	20	import java.io.IOException;
16	import java.util.ArrayList;	21	import java.util.ArrayList;
17	import java.util.Collection;	22	import java.util.Collection;
Lines 22-33 Link Here
22	import java.util.Map;	27	import java.util.Map;
23	import java.util.Set;	28	import java.util.Set;
24		29
		30	import org.eclipse.core.resources.IProject;
25	import org.eclipse.core.runtime.CoreException;	31	import org.eclipse.core.runtime.CoreException;
		32	import org.eclipse.core.runtime.IPath;
		33	import org.eclipse.core.runtime.IStatus;
		34	import org.eclipse.core.runtime.Platform;
		35	import org.eclipse.core.runtime.Status;
		36	import org.eclipse.jdt.core.JavaCore;
		37	import org.eclipse.osgi.util.NLS;
26	import org.eclipse.pde.api.tools.internal.comparator.Delta;	38	import org.eclipse.pde.api.tools.internal.comparator.Delta;
27	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	39	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
28	import org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta;	40	import org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta;
29	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;	41	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
		42	import org.eclipse.pde.api.tools.internal.util.Util;
30		43
		44	/**
		45	* The API tools build state
		46	*
		47	* @since 1.0.1
		48	*/
31	public class BuildState {	49	public class BuildState {
32	private static final IDelta[] EMPTY_DELTAS = new IDelta[0];	50	private static final IDelta[] EMPTY_DELTAS = new IDelta[0];
33	private static final String[] NO_REEXPORTED_COMPONENTS = new String[0];	51	private static final String[] NO_REEXPORTED_COMPONENTS = new String[0];
Lines 38-50 Link Here
38	private String[] reexportedComponents;	56	private String[] reexportedComponents;
39	private Set apiToolingDependentProjects;	57	private Set apiToolingDependentProjects;
40		58
41	public static BuildState read(DataInputStream in) throws IOException {	59	/**
		60	* Constructor
		61	*/
		62	BuildState() {
		63	this.compatibleChanges = new HashMap();
		64	this.breakingChanges = new HashMap();
		65	}
		66
		67	/**
		68	* Reads the build state from an input stream
		69	* @param in
		70	* @return the {@link BuildState} from the given input stream
		71	* @throws IOException
		72	*/
		73	public static BuildState read(DataInputStream in) throws IOException {
42	String pluginID= in.readUTF();	74	String pluginID= in.readUTF();
43	if (!pluginID.equals(ApiPlugin.PLUGIN_ID))	75	if (!pluginID.equals(ApiPlugin.PLUGIN_ID)) {
44	throw new IOException(BuilderMessages.build_wrongFileFormat);	76	throw new IOException(BuilderMessages.build_wrongFileFormat);
		77	}
45	String kind= in.readUTF();	78	String kind= in.readUTF();
46	if (!kind.equals("STATE")) //$NON-NLS-1$	79	if (!kind.equals("STATE")) {//$NON-NLS-1$
47	throw new IOException(BuilderMessages.build_wrongFileFormat);	80	throw new IOException(BuilderMessages.build_wrongFileFormat);
		81	}
48	if (in.readInt() != VERSION) {	82	if (in.readInt() != VERSION) {
49	// this is an old build state - a full build is required	83	// this is an old build state - a full build is required
50	return null;	84	return null;
Lines 77-82 Link Here
77	}	111	}
78	return null;	112	return null;
79	}	113	}
		114
		115	/**
		116	* Writes the given {@link BuildState} to the given output stream
		117	* @param state
		118	* @param out
		119	* @throws IOException
		120	*/
80	public static void write(BuildState state, DataOutputStream out) throws IOException {	121	public static void write(BuildState state, DataOutputStream out) throws IOException {
81	out.writeUTF(ApiPlugin.PLUGIN_ID);	122	out.writeUTF(ApiPlugin.PLUGIN_ID);
82	out.writeUTF("STATE"); //$NON-NLS-1$	123	out.writeUTF("STATE"); //$NON-NLS-1$
Lines 107-112 Link Here
107	out.writeUTF((String) iterator.next());	148	out.writeUTF((String) iterator.next());
108	}	149	}
109	}	150	}
		151
		152	/**
		153	* Read the {@link IDelta} from the build state (input stream)
		154	* @param in the input stream to read the {@link IDelta} from
		155	* @return a reconstructed {@link IDelta} from the build state
		156	* @throws IOException
		157	*/
110	private static IDelta readDelta(DataInputStream in) throws IOException {	158	private static IDelta readDelta(DataInputStream in) throws IOException {
111	// decode the delta from the build state	159	// decode the delta from the build state
112	boolean hasComponentID = in.readBoolean();	160	boolean hasComponentID = in.readBoolean();
Lines 136-141 Link Here
136	int newModifiers = modifiers >>> Delta.NEW_MODIFIERS_OFFSET;	184	int newModifiers = modifiers >>> Delta.NEW_MODIFIERS_OFFSET;
137	return new Delta(componentID, elementType, kind, flags, restrictions, oldModifiers, newModifiers, typeName, key, datas);	185	return new Delta(componentID, elementType, kind, flags, restrictions, oldModifiers, newModifiers, typeName, key, datas);
138	}	186	}
		187
		188	/**
		189	* Writes a given {@link IDelta} to the build state (the output stream)
		190	* @param delta the delta to write
		191	* @param out the stream to write to
		192	* @throws IOException
		193	*/
139	private static void writeDelta(IDelta delta, DataOutputStream out) throws IOException {	194	private static void writeDelta(IDelta delta, DataOutputStream out) throws IOException {
140	// encode a delta into the build state	195	// encode a delta into the build state
141	// int elementType, int kind, int flags, int restrictions, int modifiers, String typeName, String key, Object data	196	// int elementType, int kind, int flags, int restrictions, int modifiers, String typeName, String key, Object data
Lines 161-170 Link Here
161	}	216	}
162	}	217	}
163		218
164	BuildState() {	219	/**
165	this.compatibleChanges = new HashMap();	220	* Adds an {@link IDelta} for a compatible compatibility change to the current state
166	this.breakingChanges = new HashMap();	221	*
167	}	222	* @param delta the {@link IDelta} to add to the state
		223	*/
168	public void addCompatibleChange(IDelta delta) {	224	public void addCompatibleChange(IDelta delta) {
169	String typeName = delta.getTypeName();	225	String typeName = delta.getTypeName();
170	Set object = (Set) this.compatibleChanges.get(typeName);	226	Set object = (Set) this.compatibleChanges.get(typeName);
Lines 177-182 Link Here
177	}	233	}
178	}	234	}
179		235
		236	/**
		237	* Add an {@link IDelta} for an incompatible compatibility change to the current state
		238	*
		239	* @param delta the {@link IDelta} to add to the state
		240	*/
180	public void addBreakingChange(IDelta delta) {	241	public void addBreakingChange(IDelta delta) {
181	String typeName = delta.getTypeName();	242	String typeName = delta.getTypeName();
182	Set object = (Set) this.breakingChanges.get(typeName);	243	Set object = (Set) this.breakingChanges.get(typeName);
Lines 221-232 Link Here
221	return (IDelta[]) collector.toArray(new IDelta[collector.size()]);	282	return (IDelta[]) collector.toArray(new IDelta[collector.size()]);
222	}	283	}
223		284
		285	/**
		286	* @return the complete list of re-exported {@link IApiComponent}s
		287	*/
224	public String[] getReexportedComponents() {	288	public String[] getReexportedComponents() {
225	if (this.reexportedComponents == null) {	289	if (this.reexportedComponents == null) {
226	return NO_REEXPORTED_COMPONENTS;	290	return NO_REEXPORTED_COMPONENTS;
227	}	291	}
228	return this.reexportedComponents;	292	return this.reexportedComponents;
229	}	293	}
		294
230	/**	295	/**
231	* Remove all entries for the given type name.	296	* Remove all entries for the given type name.
232	*	297	*
Lines 235-245 Link Here
235	public void cleanup(String typeName) {	300	public void cleanup(String typeName) {
236	this.breakingChanges.remove(typeName);	301	this.breakingChanges.remove(typeName);
237	this.compatibleChanges.remove(typeName);	302	this.compatibleChanges.remove(typeName);
238	this.reexportedComponents = null;;	303	this.reexportedComponents = null;
239	}	304	}
240		305
		306	/**
		307	* Sets the current list if re-exported {@link IApiComponent}s for this build state
		308	* @param components
		309	*/
241	public void setReexportedComponents(IApiComponent[] components) {	310	public void setReexportedComponents(IApiComponent[] components) {
242	if (components == null) return;	311	if (components == null) {
		312	return;
		313	}
243	try {	314	try {
244	if (this.reexportedComponents == null) {	315	if (this.reexportedComponents == null) {
245	final int length = components.length;	316	final int length = components.length;
Lines 254-259 Link Here
254	}	325	}
255	}	326	}
256		327
		328	/**
		329	* Adds a dependent project to the listing of dependent projects
		330	* @param projectName
		331	*/
257	public void addApiToolingDependentProject(String projectName) {	332	public void addApiToolingDependentProject(String projectName) {
258	if (this.apiToolingDependentProjects == null) {	333	if (this.apiToolingDependentProjects == null) {
259	this.apiToolingDependentProjects = new HashSet(3);	334	this.apiToolingDependentProjects = new HashSet(3);
Lines 261-267 Link Here
261	this.apiToolingDependentProjects.add(projectName);	336	this.apiToolingDependentProjects.add(projectName);
262	}	337	}
263		338
		339	/**
		340	* @return the complete listing of dependent projects
		341	*/
264	public Set getApiToolingDependentProjects() {	342	public Set getApiToolingDependentProjects() {
265	return this.apiToolingDependentProjects == null ? Collections.EMPTY_SET : this.apiToolingDependentProjects;	343	return this.apiToolingDependentProjects == null ? Collections.EMPTY_SET : this.apiToolingDependentProjects;
266	}	344	}
		345	/**
		346	* Return the last built state for the given project, or null if none
		347	*/
		348	public static BuildState getLastBuiltState(IProject project) throws CoreException {
		349	if (!Util.isApiProject(project)) {
		350	// should never be requested on non-Java projects
		351	return null;
		352	}
		353	return readState(project);
		354	}
		355
		356	/**
		357	* Reads the build state for the relevant project.
		358	* @return the current {@link BuildState} for the given project or <code>null</code> if there is not one
		359	*/
		360	static BuildState readState(IProject project) throws CoreException {
		361	File file = getSerializationFile(project);
		362	if (file != null && file.exists()) {
		363	try {
		364	DataInputStream in= new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
		365	try {
		366	return read(in);
		367	} finally {
		368	if (ApiAnalysisBuilder.DEBUG) {
		369	System.out.println("Saved state thinks last build failed for " + project.getName()); //$NON-NLS-1$
		370	}
		371	in.close();
		372	}
		373	} catch (Exception e) {
		374	e.printStackTrace();
		375	throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Platform.PLUGIN_ERROR, "Error reading last build state for project "+ project.getName(), e)); //$NON-NLS-1$
		376	}
		377	} else if (ApiAnalysisBuilder.DEBUG) {
		378	if (file == null) {
		379	System.out.println("Project does not exist: " + project); //$NON-NLS-1$
		380	} else {
		381	System.out.println("Build state file " + file.getPath() + " does not exist"); //$NON-NLS-1$ //$NON-NLS-2$
		382	}
		383	}
		384	return null;
		385	}
		386
		387	/**
		388	* Sets the last built state for the given project, or null to reset it.
		389	*
		390	* @param project the project to set a state for
		391	* @param state the {@link BuildState} to set as the last state
		392	*/
		393	public static void setLastBuiltState(IProject project, BuildState state) throws CoreException {
		394	if (Util.isApiProject(project)) {
		395	// should never be requested on non-Java projects
		396	if (state != null) {
		397	saveBuiltState(project, state);
		398	} else {
		399	try {
		400	File file = getSerializationFile(project);
		401	if (file != null && file.exists()) {
		402	file.delete();
		403	}
		404	} catch(SecurityException se) {
		405	// could not delete file: cannot do much more
		406	}
		407	}
		408	}
409	}
410
411	/**
412	* Returns the {@link File} to use for saving and restoring the last built state for the given project.
413	*
414	* @param project gets the saved state file for the given project
415	* @return the {@link File} to use for saving and restoring the last built state for the given project.
416	*/
417	static File getSerializationFile(IProject project) {
418	if (!project.exists()) {
419	return null;
420	}
421	IPath workingLocation = project.getWorkingLocation(ApiPlugin.PLUGIN_ID);
422	return workingLocation.append("state.dat").toFile(); //$NON-NLS-1$
423	}
424
425	/**
426	* Saves the current build state
427	* @param project
428	* @param state
429	* @throws CoreException
430	*/
431	static void saveBuiltState(IProject project, BuildState state) throws CoreException {
432	if (ApiAnalysisBuilder.DEBUG) {
433	System.out.println("Saving build state for project: "+project.getName()); //$NON-NLS-1$
434	}
435	File file = BuildState.getSerializationFile(project);
436	if (file == null) return;
437	long t = 0;
438	if (ApiAnalysisBuilder.DEBUG) {
439	t = System.currentTimeMillis();
440	}
441	try {
442	DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
443	try {
444	write(state, out);
445	} finally {
446	out.close();
447	}
448	} catch (RuntimeException e) {
449	try {
450	file.delete();
451	} catch(SecurityException se) {
452	// could not delete file: cannot do much more
453	}
454	throw new CoreException(
455	new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, Platform.PLUGIN_ERROR,
456	NLS.bind(BuilderMessages.build_cannotSaveState, project.getName()), e));
457	} catch (IOException e) {
458	try {
459	file.delete();
460	} catch(SecurityException se) {
461	// could not delete file: cannot do much more
462	}
463	throw new CoreException(
464	new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, Platform.PLUGIN_ERROR,
465	NLS.bind(BuilderMessages.build_cannotSaveState, project.getName()), e));
466	}
467	if (ApiAnalysisBuilder.DEBUG) {
468	t = System.currentTimeMillis() - t;
469	System.out.println(NLS.bind(BuilderMessages.build_saveStateComplete, String.valueOf(t)));
470	}
471	}
267	}	472	}




 *******************************************************************************/
package org.eclipse.pde.api.tools.internal.builder;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;

		SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_builder, 2);
		final IProject[] projects = getRequiredProjects(true);
		IApiBaseline baseline = ApiPlugin.getDefault().getApiBaselineManager().getDefaultApiBaseline();
		IApiBaseline wbaseline = ApiPlugin.getDefault().getApiBaselineManager().getWorkspaceBaseline();
		if (wbaseline == null) {
			if (DEBUG) {
				System.err.println("Could not retrieve a workspace profile"); //$NON-NLS-1$
			}
			return NO_PROJECTS;
		}
		try {
			switch(kind) {
				case FULL_BUILD : {
					if (DEBUG) {
						System.out.println("Performing full build as requested by user"); //$NON-NLS-1$
					}
					buildAll(baseline, wbaseline, localMonitor.newChild(1));
					break;
				}
				case AUTO_BUILD :
				case INCREMENTAL_BUILD : {
					this.buildstate = BuildState.getLastBuiltState(currentproject);
					if (this.buildstate == null) {
						buildAll(baseline, wbaseline, localMonitor.newChild(1));
						break;
					}
					else if(worthDoingFullBuild(projects)) {
						buildAll(baseline, wbaseline, localMonitor.newChild(1));
						break;
					IResourceDelta[] deltas = getDeltas(projects);
					if(deltas.length < 1) {
						buildAll(baseline, localMonitor.newChild(1));
					}
					else {
						IResourceDelta[] deltas = getDeltas(projects);
						if(deltas.length < 1) {
							buildAll(baseline, wbaseline, localMonitor.newChild(1));
						}
						else {	
							IResourceDelta manifest = null;
							IResourceDelta filters = null;
							for (int i = 0; i < deltas.length; i++) {
								manifest = deltas[i].findMember(MANIFEST_PATH);
								if(manifest != null) {
									break;
								}
								filters = deltas[i].findMember(FILTER_PATH);
								if(filters != null){
									break;
								}
							}
							if (manifest != null || filters != null) {
								if (DEBUG) {
									System.out.println("Performing full build since MANIFEST.MF or .api_filters was modified"); //$NON-NLS-1$
		 						}
								buildAll(baseline, wbaseline, localMonitor.newChild(1));
							}
							else {
								State state = (State)JavaModelManager.getJavaModelManager().getLastBuiltState(this.currentproject, localMonitor.newChild(1));
								if(state == null) {
									buildAll(baseline, wbaseline, localMonitor.newChild(1));
									break;
								}
								BuildState.setLastBuiltState(this.currentproject, null);
								IncrementalApiBuilder builder = new IncrementalApiBuilder(this);
								builder.build(baseline, wbaseline, deltas, state, this.buildstate, localMonitor.newChild(1));
							}
						}
						if (manifest != null || filters != null) {
							if (DEBUG) {
								System.out.println("Performing full build since MANIFEST.MF or .api_filters was modified"); //$NON-NLS-1$
	 						}
							buildAll(baseline, localMonitor.newChild(1));
						}
						else {
							IncrementalApiBuilder builder = new IncrementalApiBuilder(this);
							builder.build(baseline, deltas, this.buildstate, localMonitor.newChild(1));
						}
					}
				}	

			if(baseline != null) {
				baseline.close();
			}
			wbaseline.close();
			if(monitor != null) {
				monitor.done();
			}

						this.buildstate.addApiToolingDependentProject(project.getName());
					}
				}
				BuildState.saveBuiltState(this.currentproject, this.buildstate);
				this.buildstate = null;
			}
		}

		return projects;
	}
	
	/**
	 * if its worth doing a full build considering the given set if projects
	 * @param projects projects to check the build state for
	 * @return true if a full build should take place, false otherwise
	 */
	boolean worthDoingFullBuild(IProject[] projects) {
		Set apiToolingDependentProjects = this.buildstate.getApiToolingDependentProjects();
		for (int i = 0, max = projects.length; i < max; i++) {
			IProject currentProject = projects[i];

	
	/**
	 * Performs a full build for the project
	 * @param baseline the default baseline 
	 * @param wbaseline the workspace baseline
	 * @param monitor
	 */
	void buildAll(IApiBaseline baseline, IApiBaseline wbaseline, IProgressMonitor monitor) throws CoreException {
		IApiBaseline wsprofile = null;
		try {
			BuildState.setLastBuiltState(this.currentproject, null);
			this.buildstate = new BuildState();
			SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 4);
			localMonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_initializing_analyzer, currentproject.getName()));

			IPluginModelBase currentModel = getCurrentModel();
			if (currentModel != null) {
				localMonitor.subTask(BuilderMessages.building_workspace_profile);
				wsprofile = getWorkspaceProfile();
				updateMonitor(localMonitor, 1);
				if (wsprofile == null) {
					if (DEBUG) {
						System.err.println("Could not retrieve a workspace profile"); //$NON-NLS-1$
					}
					return;
				}
				String id = currentModel.getBundleDescription().getSymbolicName();
				// Compatibility checks
				IApiComponent apiComponent = wbaseline.getApiComponent(id);
				if(apiComponent != null) {
					getAnalyzer().analyzeComponent(this.buildstate, null, null, baseline, apiComponent, null, null, localMonitor.newChild(1));
					updateMonitor(localMonitor, 1);

			}
		}
		finally {
			if(wsprofile != null) {
				wsprofile.close();
			}
			if(monitor != null) {
				monitor.done();
			}

	/**
	 * Returns the {@link IApiMarkerConstants} problem type given the 
	 * problem category
	 * @param category the problem category - see {@link IApiProblem} for problem categories
	 * @param kind the kind of the problem - see {@link IApiProblem} for problem kinds
	 * @return the problem type or <code>null</code>
	 */
	String getProblemTypeFromCategory(int category, int kind) {
		switch(category) {
			case IApiProblem.CATEGORY_API_COMPONENT_RESOLUTION : {
				return IApiMarkerConstants.API_COMPONENT_RESOLUTION_PROBLEM_MARKER;

	 * Creates an {@link IMarker} on the resource specified
	 * in the problem (via its path) with the given problem
	 * attributes
	 * @param category the category of the problem - see {@link IApiProblem} for categories
	 * @param type the marker type to create - see {@link IApiMarkerConstants} for types
	 * @param problem the problem to create a marker from
	 */
	void createMarkerForProblem(int category, String type, IApiProblem problem) {
		IResource resource = resolveResource(problem);
		if(resource == null) {
			return;

	 * @param problem the problem to get the resource for
	 * @return the resource or <code>null</code>
	 */
	IResource resolveResource(IApiProblem problem) {
		String resourcePath = problem.getResourcePath();
		if (resourcePath == null) {
			return null;

	 * @param args
	 * @return a single string attribute from an array or arguments
	 */
	String createArgAttribute(String[] args) {
		StringBuffer buff = new StringBuffer();
		for(int i = 0; i < args.length; i++) {
			buff.append(args[i]);

			updateMonitor(localmonitor, 1);
		}
		finally {
			BuildState.setLastBuiltState(this.currentproject, null);
			localmonitor.done();
		}
	}

	 * Cleans the .api_settings file for the given project
	 * @param project
	 */
	void cleanupApiDescription(IProject project) {
		if(project != null && project.exists()) {
			ApiDescriptionManager.getDefault().clean(JavaCore.create(project), true, true);
		}

	 * @param projects
	 * @return
	 */
	IResourceDelta[] getDeltas(IProject[] projects) {
		if(DEBUG) {
			System.out.println("Searching for deltas for build of project: "+this.currentproject.getName()); //$NON-NLS-1$
		}

	/**
	 * Returns the complete listing of required projects from the classpath of the backing project
	 * @param includeBinaryPrerequisites
	 * @return the list of projects required 
	 * @throws CoreException
	 */
	IProject[] getRequiredProjects(boolean includebinaries) throws CoreException {
		IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
		if (this.currentproject == null || workspaceRoot == null) { 
			return new IProject[0];

		projects.toArray(result);
		return result;
	}

	/**
	 * @return the workspace {@link IApiProfile}
	 */
	IApiBaseline getWorkspaceProfile() throws CoreException {
		return ApiPlugin.getDefault().getApiBaselineManager().getWorkspaceBaseline();
	}
	
	/**
	 * Returns the output paths of the given project or <code>null</code> if none have been computed

	 * @param entry
	 * @return true if the specified {@link IClasspathEntry} is optional, false otherwise
	 */
	boolean isOptional(IClasspathEntry entry) {
		IClasspathAttribute[] attribs = entry.getExtraAttributes();
		for (int i = 0, length = attribs.length; i < length; i++) {
			IClasspathAttribute attribute = attribs[i];

	public String toString() {
		return NLS.bind(BuilderMessages.ApiAnalysisBuilder_builder_for_project, this.currentproject.getName());
	}
	
	/**
	 * Return the last built state for the given project, or null if none
	 */
	public static BuildState getLastBuiltState(IProject project) throws CoreException {
		if (!Util.isApiProject(project)) {
			// should never be requested on non-Java projects
			return null;
		}
		return readState(project);
	}
	
	/**
	 * Reads the build state for the relevant project.
	 */
	static BuildState readState(IProject project) throws CoreException {
		File file = getSerializationFile(project);
		if (file != null && file.exists()) {
			try {
				DataInputStream in= new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
				try {
					return BuildState.read(in);
				} finally {
					if (DEBUG) {
						System.out.println("Saved state thinks last build failed for " + project.getName()); //$NON-NLS-1$
					}
					in.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Platform.PLUGIN_ERROR, "Error reading last build state for project "+ project.getName(), e)); //$NON-NLS-1$
			}
		} else if (DEBUG) {
			if (file == null) {
				System.out.println("Project does not exist: " + project); //$NON-NLS-1$
			} else {
				System.out.println("Build state file " + file.getPath() + " does not exist"); //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		return null;
	}

	/**
	 * Sets the last built state for the given project, or null to reset it.
	 */
	public static void setLastBuiltState(IProject project, BuildState state) throws CoreException {
		if (Util.isApiProject(project)) {
			// should never be requested on non-Java projects
			if (state != null) {
				saveBuiltState(project, state);
			} else {
				try {
					File file = getSerializationFile(project);
					if (file != null && file.exists()) {
						file.delete();
					}
				} catch(SecurityException se) {
					// could not delete file: cannot do much more
				}
			}
		}
	}	

	/**
	 * Returns the File to use for saving and restoring the last built state for the given project.
	 */
	static File getSerializationFile(IProject project) {
		if (!project.exists()) {
			return null;
		}
		IPath workingLocation = project.getWorkingLocation(ApiPlugin.PLUGIN_ID);
		return workingLocation.append("state.dat").toFile(); //$NON-NLS-1$
	}

	/**
	 * Saves the current build state
	 * @param project
	 * @param state
	 * @throws CoreException
	 */
	static void saveBuiltState(IProject project, BuildState state) throws CoreException {
		if (DEBUG) {
			System.out.println("Saving build state for project: "+project.getName()); //$NON-NLS-1$
		}
		File file = getSerializationFile(project);
		if (file == null) return;
		long t = 0;
		if (DEBUG) {
			t = System.currentTimeMillis();
		}
		try {
			DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
			try {
				BuildState.write(state, out);
			} finally {
				out.close();
			}
		} catch (RuntimeException e) {
			try {
				file.delete();
			} catch(SecurityException se) {
				// could not delete file: cannot do much more
			}
			throw new CoreException(
				new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, Platform.PLUGIN_ERROR,
					NLS.bind(BuilderMessages.build_cannotSaveState, project.getName()), e)); 
		} catch (IOException e) {
			try {
				file.delete();
			} catch(SecurityException se) {
				// could not delete file: cannot do much more
			}
			throw new CoreException(
				new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, Platform.PLUGIN_ERROR,
					NLS.bind(BuilderMessages.build_cannotSaveState, project.getName()), e)); 
		}
		if (DEBUG) {
			t = System.currentTimeMillis() - t;
			System.out.println(NLS.bind(BuilderMessages.build_saveStateComplete, String.valueOf(t))); 
		}
	}

	/**
	 * Clears the last build state by setting it to <code>null</code>
	 * @throws CoreException
	 */
	void clearLastState() throws CoreException {
		setLastBuiltState(this.currentproject, null);
	}
}

Lines 14-19 Link Here

(-)buildnotes_api_tools.html (+1 lines)
14	<!-- NEW -->	14	<!-- NEW -->
15	<h2>%date%</h2>	15	<h2>%date%</h2>
16	<h3>Problem Reports Fixed</h3>	16	<h3>Problem Reports Fixed</h3>
		17	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=271110">Bug 271110</a>: "The minor version should be incremented" stays on MANIFEST.MF after removing all problems<br>
17	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=233883">Bug 233883</a>: [api tooling] Reports wrong error on correct @since 3.4 tag<br>	18	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=233883">Bug 233883</a>: [api tooling] Reports wrong error on correct @since 3.4 tag<br>
18	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=270992">Bug 270992</a>: Unable to add EE descriptions from repository<br>	19	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=270992">Bug 270992</a>: Unable to add EE descriptions from repository<br>
19	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=270857">Bug 270857</a>: unused import in manifest<br>	20	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=270857">Bug 270857</a>: unused import in manifest<br>

Lines 18-23 Link Here

(-)src/org/eclipse/pde/api/tools/builder/tests/tags/TagTest.java (+38 lines)
18		18
19	import org.eclipse.core.runtime.IPath;	19	import org.eclipse.core.runtime.IPath;
20	import org.eclipse.core.runtime.Path;	20	import org.eclipse.core.runtime.Path;
		21	import org.eclipse.jdt.core.IJavaProject;
		22	import org.eclipse.jdt.core.IType;
21	import org.eclipse.jdt.core.tests.junit.extension.TestCase;	23	import org.eclipse.jdt.core.tests.junit.extension.TestCase;
22	import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;	24	import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;
23	import org.eclipse.pde.api.tools.builder.tests.ApiTestingEnvironment;	25	import org.eclipse.pde.api.tools.builder.tests.ApiTestingEnvironment;
Lines 195-198 Link Here
195	protected String getTestingProjectName() {	197	protected String getTestingProjectName() {
196	return "tagtest";	198	return "tagtest";
197	}	199	}
		200
		201	/**
		202	* Deploys a full build test for API Javadoc tags using the given source file in the specified package,
		203	* looking for problems specified from {@link #getExpectedProblemIds()()}
		204	* @param packagename
		205	* @param sourcename
		206	* @param expectingproblems
		207	* @param buildtype the type of build to perform. One of:
		208	* <ol>
		209	* <li>IncrementalProjectBuilder#FULL_BUILD</li>
		210	* <li>IncrementalProjectBuilder#INCREMENTAL_BUILD</li>
		211	* <li>IncrementalProjectBuilder#CLEAN_BUILD</li>
		212	* </ol>
		213	* @param buildworkspace true if the workspace should be built, false if the created project should be built
		214	*/
		215	protected void deployTagTest(String packagename, String sourcename, boolean expectingproblems, int buildtype, boolean buildworkspace) {
		216	try {
		217	IPath path = assertProject(sourcename, packagename);
		218	doBuild(buildtype, (buildworkspace ? null : path));
		219	expectingNoJDTProblems();
		220	IJavaProject jproject = getEnv().getJavaProject(path);
		221	IType type = jproject.findType(packagename, sourcename);
		222	assertNotNull("The type "+sourcename+" from package "+packagename+" must exist", type);
		223	IPath sourcepath = type.getPath();
		224	if(expectingproblems) {
		225	expectingOnlySpecificProblemsFor(sourcepath, getExpectedProblemIds());
		226	assertProblems(getEnv().getProblems());
		227	}
		228	else {
		229	expectingNoProblemsFor(sourcepath);
		230	}
		231	}
		232	catch(Exception e) {
		233	fail(e.getMessage());
		234	}
		235	}
198	}	236	}




	}
	
	/**
	 * Deploys a standard API usage test with the test project being created and the given source is imported in the testing project
	 * into the given project.
	 * 
	 * This method assumes that the reference and testing project have been imported into the workspace already.
	 * 
	 * @param packagename
	 * @param sourcename
	 * @param expectingproblems
	 * @param buildtype the type of build to perform. One of:
	 * <ol>
	 * <li>IncrementalProjectBuilder#FULL_BUILD</li>
	 * <li>IncrementalProjectBuilder#INCREMENTAL_BUILD</li>
	 * <li>IncrementalProjectBuilder#CLEAN_BUILD</li>
	 * </ol>
	 * @param buildworkspace
	 */
	protected void deployUsageTest(String packagename, String sourcename, boolean expectingproblems, int buildtype, boolean buildworkspace) {
		try {
			IProject project = getEnv().getProject(getTestingProjectName());
			assertNotNull("the testing project "+getTestingProjectName()+" must be in the workspace", project);
			assertSource(project, packagename, sourcename);
			doBuild(buildtype, (buildworkspace ? null : project.getFullPath()));
			expectingNoJDTProblems();
			IJavaProject jproject = getEnv().getJavaProject(getTestingProjectName());
			IType type = jproject.findType(packagename, sourcename);
			assertNotNull("The type "+sourcename+" from package "+packagename+" must exist", type);
			IPath sourcepath = type.getPath();
			if(expectingproblems) {
				expectingOnlySpecificProblemsFor(sourcepath, getExpectedProblemIds());
				assertProblems(getEnv().getProblems());
			}
			else {
				expectingNoProblemsFor(sourcepath);
			}
		}
		catch(Exception e) {
			fail(e.getMessage());
		}
	}
	
	/**
	 * Deploys a full build test for API Javadoc tags using the given source file in the specified package,
	 * looking for problems specified from {@link #getExpectedProblemIds()()}
	 * @param packagename
	 * @param sourcename
	 * @param expectingproblems
	 * @param buildtype the type of build to perform. One of:
	 * <ol>
	 * <li>IncrementalProjectBuilder#FULL_BUILD</li>
	 * <li>IncrementalProjectBuilder#INCREMENTAL_BUILD</li>
	 * <li>IncrementalProjectBuilder#CLEAN_BUILD</li>
	 * </ol>
	 * @param buildworkspace true if the workspace should be built, false if the created project should be built
	 */
	protected void deployTagTest(String packagename, String sourcename, boolean expectingproblems, int buildtype, boolean buildworkspace) {
		try {
			IPath path = assertProject(sourcename, packagename);
			doBuild(buildtype, (buildworkspace ? null : path));
			expectingNoJDTProblems();
			IJavaProject jproject = getEnv().getJavaProject(path);
			IType type = jproject.findType(packagename, sourcename);
			assertNotNull("The type "+sourcename+" from package "+packagename+" must exist", type);
			IPath sourcepath = type.getPath();
			if(expectingproblems) {
				expectingOnlySpecificProblemsFor(sourcepath, getExpectedProblemIds());
				assertProblems(getEnv().getProblems());
			}
			else {
				expectingNoProblemsFor(sourcepath);
			}
		}
		catch(Exception e) {
			fail(e.getMessage());
		}
	}
	
	/**
	 * Sets up the project for a given test using the specified source.
	 * The listing of source names and package names must be equal in size, as each source name will be
	 * placed in the the corresponding package listed in packagenames

Lines 21-26 Link Here

(-)src/org/eclipse/pde/api/tools/builder/tests/usage/UsageTest.java (+43 lines)
21	import org.eclipse.core.resources.IncrementalProjectBuilder;	21	import org.eclipse.core.resources.IncrementalProjectBuilder;
22	import org.eclipse.core.runtime.IPath;	22	import org.eclipse.core.runtime.IPath;
23	import org.eclipse.core.runtime.Path;	23	import org.eclipse.core.runtime.Path;
		24	import org.eclipse.jdt.core.IJavaProject;
		25	import org.eclipse.jdt.core.IType;
24	import org.eclipse.jdt.core.tests.junit.extension.TestCase;	26	import org.eclipse.jdt.core.tests.junit.extension.TestCase;
25	import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;	27	import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;
26	import org.eclipse.pde.api.tools.model.tests.TestSuiteHelper;	28	import org.eclipse.pde.api.tools.model.tests.TestSuiteHelper;
Lines 172-177 Link Here
172	}	174	}
173		175
174	/**	176	/**
		177	* Deploys a standard API usage test with the test project being created and the given source is imported in the testing project
		178	* into the given project.
		179	*
		180	* This method assumes that the reference and testing project have been imported into the workspace already.
		181	*
		182	* @param packagename
		183	* @param sourcename
		184	* @param expectingproblems
		185	* @param buildtype the type of build to perform. One of:
		186	* <ol>
		187	* <li>IncrementalProjectBuilder#FULL_BUILD</li>
		188	* <li>IncrementalProjectBuilder#INCREMENTAL_BUILD</li>
		189	* <li>IncrementalProjectBuilder#CLEAN_BUILD</li>
		190	* </ol>
		191	* @param buildworkspace
		192	*/
		193	protected void deployUsageTest(String packagename, String sourcename, boolean expectingproblems, int buildtype, boolean buildworkspace) {
		194	try {
		195	IProject project = getEnv().getProject(getTestingProjectName());
		196	assertNotNull("the testing project "+getTestingProjectName()+" must be in the workspace", project);
		197	assertSource(project, packagename, sourcename);
		198	doBuild(buildtype, (buildworkspace ? null : project.getFullPath()));
		199	expectingNoJDTProblems();
		200	IJavaProject jproject = getEnv().getJavaProject(getTestingProjectName());
		201	IType type = jproject.findType(packagename, sourcename);
		202	assertNotNull("The type "+sourcename+" from package "+packagename+" must exist", type);
		203	IPath sourcepath = type.getPath();
		204	if(expectingproblems) {
		205	expectingOnlySpecificProblemsFor(sourcepath, getExpectedProblemIds());
		206	assertProblems(getEnv().getProblems());
		207	}
		208	else {
		209	expectingNoProblemsFor(sourcepath);
		210	}
		211	}
		212	catch(Exception e) {
		213	fail(e.getMessage());
		214	}
		215	}
		216
		217	/**
175	* @return all of the child test classes of this class	218	* @return all of the child test classes of this class
176	*/	219	*/
177	private static Class[] getAllTestClasses() {	220	private static Class[] getAllTestClasses() {

Lines 23-29 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/wizards/ProjectUpdateChange.java (-2 / +2 lines)
23	import org.eclipse.ltk.core.refactoring.Change;	23	import org.eclipse.ltk.core.refactoring.Change;
24	import org.eclipse.ltk.core.refactoring.RefactoringStatus;	24	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
25	import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;	25	import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;
26	import org.eclipse.pde.api.tools.internal.builder.ApiAnalysisBuilder;	26	import org.eclipse.pde.api.tools.internal.builder.BuildState;
27	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	27	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
28	import org.eclipse.pde.api.tools.internal.util.Util;	28	import org.eclipse.pde.api.tools.internal.util.Util;
29	import org.eclipse.pde.api.tools.ui.internal.IApiToolsConstants;	29	import org.eclipse.pde.api.tools.ui.internal.IApiToolsConstants;
Lines 101-107 Link Here
101	* If autobuild is off, clear the last build state to force a full build of	101	* If autobuild is off, clear the last build state to force a full build of
102	* this project on the next build.	102	* this project on the next build.
103	*/	103	*/
104	ApiAnalysisBuilder.setLastBuiltState(this.fProject, null);	104	BuildState.setLastBuiltState(this.fProject, null);
105	}	105	}
106	if(!pm.isCanceled()) {	106	if(!pm.isCanceled()) {
107	pm.worked(1);	107	pm.worked(1);

Return to bug 233643