Attachment #127856 for bug #233643




					}
				}
				if (changedTypes != null) {
					// check the ones not already checked as part of type names check
					for (int i = 0; i < changedTypes.length; i++) {
						String typeName = changedTypes[i];
						if (typeNamesSet == null || !typeNamesSet.remove(typeName)) {

							Util.EMPTY_STRING);
				}
			}
			// analyze version of required components
			ReexportedBundleVersionInfo info = null;
			if (problem != null) {
				switch (problem.getKind()) {

						}
						break;
					case IApiProblem.MINOR_VERSION_CHANGE :
						// check if there is a version change required due to re-exported bundles
						info = checkBundleVersionsOfReexportedBundles(reference, component);
						if (info != null) {
							switch(info.kind) {

						}
						break;
					case IApiProblem.MINOR_VERSION_CHANGE_NO_NEW_API :
						// check if there is a version change required due to re-exported bundles
						info = checkBundleVersionsOfReexportedBundles(reference, component);
						if (info != null) {
							switch(info.kind) {

Lines 20-25 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BuilderMessages.java (+1 lines)
20	public static String checking_api_usage;	20	public static String checking_api_usage;
21		21
22	public static String AbstractTypeLeakDetector_vis_type_has_no_api_description;	22	public static String AbstractTypeLeakDetector_vis_type_has_no_api_description;
		23	public static String ApiAnalysisBuilder_builder_for_project;
23	public static String ApiAnalysisBuilder_finding_affected_source_files;	24	public static String ApiAnalysisBuilder_finding_affected_source_files;
24	public static String ApiAnalysisBuilder_initializing_analyzer;	25	public static String ApiAnalysisBuilder_initializing_analyzer;
25	public static String ApiProblemFactory_problem_message_not_found;	26	public static String ApiProblemFactory_problem_message_not_found;




import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarFile;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
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;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;

 */
public class ApiAnalysisBuilder extends IncrementalProjectBuilder {
	/**
	 * Visits a resource delta to determine if the changes have been made that might required a rebuild:
	 * - modification to the manifest file
	 * - removal of the .api_filter file
	 */
	class ResourceDeltaVisitor implements IResourceDeltaVisitor {
		IProject[] projects;
		public ResourceDeltaVisitor(IProject[] projects) {
			this.projects = projects;
		}
		private boolean fRequireFullBuild = false;

		/**
		 * Returns whether a full build should be run.
		 * 
		 * @return whether a full build should be run
		 */
		boolean shouldRunFullBuild() {
			return fRequireFullBuild;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
		 */
		public boolean visit(IResourceDelta delta) throws CoreException {
			switch (delta.getResource().getType()) {
				case IResource.ROOT:
				case IResource.PROJECT:
					return !fRequireFullBuild;
				case IResource.FOLDER:
					return !fRequireFullBuild; 
				case IResource.FILE:
					if (delta.getResource().getProjectRelativePath().equals(MANIFEST_PATH)) {
						fRequireFullBuild = true;
						break;
					}
					IResource resource = delta.getResource();
					String fileName = resource.getName();
					if (Util.isClassFile(fileName)) {
						findAffectedSourceFiles(delta);
					} else if (Util.isJavaFileName(fileName)) {
						IProject project = resource.getProject();
						if (fCurrentProject.equals(project)) {
							if (delta.getKind() == IResourceDelta.ADDED) {
								fAddedRemovedDeltas.add(delta);
							}
							fTypesToCheck.add(resource);
						} else if (this.projects != null) {
							loop: for (int i = 0, max = this.projects.length; i < max; i++) {
								if (this.projects[i].equals(project)) {
									fTypesToCheck.add(resource);
									break loop;
								}
							}
						}
					} else if (!fRequireFullBuild && IApiCoreConstants.API_FILTERS_XML_NAME.equals(fileName)) {
						switch(delta.getKind()) {
							case IResourceDelta.REMOVED :
							case IResourceDelta.REPLACED :
							case IResourceDelta.CHANGED :
							case IResourceDelta.ADDED :
								fRequireFullBuild = true;
						}
					}
			}
			return false;
		}
	}
	/**
	 * Constant used for controlling tracing in the API tool builder
	 */
	static boolean DEBUG = Util.DEBUG;
	
	/**
	 * Project relative path to the manifest file.
	 */
	static final IPath MANIFEST_PATH = new Path(JarFile.MANIFEST_NAME);
	
	/**
	 * Project relative path to the .api_filters file
	 */
	static final IPath FILTER_PATH = new Path(".settings").append(IApiCoreConstants.API_FILTERS_XML_NAME); //$NON-NLS-1$
	
	/**
	 * Empty listing of projects to be returned by the builder if there is nothing to do
	 */
	static final IProject[] NO_PROJECTS = new IProject[0];

	/**
	 * Constant representing the name of the 'source' attribute on API tooling markers.
	 * Value is <code>Api Tooling</code>
	 */
	static final String SOURCE = "Api Tooling"; //$NON-NLS-1$
	
	/**
	 * Method used for initializing tracing in the API tool builder

	public static void setDebug(boolean debugValue) {
		DEBUG = debugValue || Util.DEBUG;
	}
	
	/**
	 * The current project for which this builder was defined
	 */
	private IProject currentproject = null;
	
	/**
	 * The API analyzer for this builder
	 */
	private IApiAnalyzer analyzer = null;
	
	/**
	 * Maps prerequisite projects to their output location(s)
	 */
	private HashMap projecttooutputlocations = new HashMap();
	
	/**
	 * List of type names to lookup for each project context to find dependents of
	 */
	private StringSet fTypes = new StringSet(3);
	
	/**
	 * List of package names to qualify type names
	 */
	private StringSet fPackages = new StringSet(3);
	
	/**
	 * The type that we want to check for API problems
	 */
	private HashSet fTypesToCheck = new HashSet();
	/**
	 * The set of added/removed deltas that come directly from the builder resource delta 
	 */
	private HashSet fAddedRemovedDeltas = new HashSet(5);
	
	/**
	 * Current build state
	 */
	private BuildState buildstate = null;
	
	/**
	 * Cleans up markers associated with API tooling on the given resource.
	 * 
	 * @param resource
	 */
	void cleanupMarkers(IResource resource) {
		cleanupUsageMarkers(resource);
		cleanupCompatibilityMarkers(resource);
		cleanupUnsupportedTagMarkers(resource);

	 * Cleans up unsupported Javadoc tag markers on the specified resource
	 * @param resource
	 */
	void cleanupUnsupportedTagMarkers(IResource resource) {
		try {
			if(DEBUG) {
				System.out.println("cleaning unsupported tag problems"); //$NON-NLS-1$

	 * Cleans up only API compatibility markers on the given {@link IResource}
	 * @param resource the given resource
	 */
	void cleanupCompatibilityMarkers(IResource resource) {
		try {
			if (resource != null && resource.isAccessible()) {
				resource.deleteMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);

	 * cleans up only API usage markers from the given {@link IResource}
	 * @param resource
	 */
	void cleanupUsageMarkers(IResource resource) {
		try {
			if (resource != null && resource.isAccessible()) {
				resource.deleteMarkers(IApiMarkerConstants.API_USAGE_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);

		}
	}
	
	/**
	 * Adds a type to search for dependents of in considered projects for an incremental build
	 * 
	 * @param path
	 */
	private void addDependentsOf(IPath path) {
		// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
		path = path.setDevice(null);
		String packageName = path.removeLastSegments(1).toString();
		String typeName = path.lastSegment();
		int memberIndex = typeName.indexOf('$');
		if (memberIndex > 0) {
			typeName = typeName.substring(0, memberIndex);
		}
		if (fTypes.add(typeName) && fPackages.add(packageName) && DEBUG) {
			System.out.println("  will look for dependents of " + typeName + " in " + packageName); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.resources.IncrementalProjectBuilder#build(int, java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException {
		this.currentproject = getProject();
		this.analyzer = getAnalyzer();
		if (!this.currentproject.isAccessible() || !this.currentproject.hasNature(ApiPlugin.NATURE_ID) || hasBeenBuilt(this.currentproject)) {
			return NO_PROJECTS;
				!fCurrentProject.hasNature(ApiPlugin.NATURE_ID) ||
				hasBeenBuilt(fCurrentProject)) {
			return new IProject[0];
		}
		if (DEBUG) {
			System.out.println("\nStarting build of " + this.currentproject.getName() + " @ " + new Date(System.currentTimeMillis())); //$NON-NLS-1$ //$NON-NLS-2$
		}
		updateMonitor(monitor, 0);
		SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_builder, 2);

				case AUTO_BUILD :
				case INCREMENTAL_BUILD : {
					IResourceDelta[] deltas = getDeltas(projects);
					if(deltas.length == 0) {
					fBuildState = getLastBuiltState(fCurrentProject);
					if (fBuildState == null) {
						buildAll(baseline, localMonitor.newChild(1));
						break;
					}
					this.buildstate = getLastBuiltState(currentproject);
					if (this.buildstate == null) {
						buildAll(baseline, localMonitor.newChild(1));
						break;
					}
					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 (allProjects.size() != 0) {
								reexportedProjects = new IProject[allProjects.size()];
								allProjects.toArray(reexportedProjects);
							}
						}
					}
					if (manifest != null || filters != null) {
						if (DEBUG) {
							System.out.println("Performing full build since MANIFEST.MF or .api_filters was modified"); //$NON-NLS-1$
								shouldRunFullBuild = true;
								break;
							}
						}
						buildAll(baseline, localMonitor.newChild(1));
					}
					IProject[] reexportedProjects = null;
					String[] projectNames = this.buildstate.getReexportedComponents();
					int length = projectNames.length;
					if (length != 0) {
						List allProjects = new ArrayList();
						IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
						for (int i = 0, max = projectNames.length; i < max; i++) {
							String projectName = projectNames[i];
							IProject project = root.getProject(projectName);
							if (project.isAccessible()) {
								// select only projects that don't exist in the reference baseline
								if (baseline != null && baseline.getApiComponent(projectName) == null) {
									allProjects.add(project);
								}
							}
						}
						if (allProjects.size() != 0) {
							reexportedProjects = new IProject[allProjects.size()];
							allProjects.toArray(reexportedProjects);
						}
					}
					IncrementalApiBuilder incbuilder = new IncrementalApiBuilder(this);
					incbuilder.build(baseline, deltas, localMonitor.newChild(1));
					}
					break;
				}
				updateMonitor(monitor, 0);
			updateMonitor(monitor, 0);
		} catch(CoreException e) {
			IStatus status = e.getStatus();
			if (status == null || status.getCode() != ApiPlugin.REPORT_BASELINE_IS_DISPOSED) {

			}
			ApiPlugin.log(e);
		} finally {
			this.projecttooutputlocations.clear();
			fPackages.clear();
			fTypesToCheck.clear();
			fAddedRemovedDeltas.clear();
			fProjectToOutputLocations.clear();
			updateMonitor(monitor, 0);
			this.analyzer.dispose();
			if(baseline != null) {
				baseline.close();
			}
			if(monitor != null) {
				monitor.done();
			}
			if (this.buildstate != null) {
				saveBuiltState(this.currentproject, this.buildstate);
				this.buildstate = null;
			}
		}
		if (DEBUG) {
			System.out.println("Finished build of " + currentproject.getName() + " @ " + new Date(System.currentTimeMillis())); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return projects;
	}

	 * Performs a full build for the project
	 * @param monitor
	 */
	void buildAll(IApiBaseline baseline, IProgressMonitor monitor) throws CoreException {
		IApiBaseline wsprofile = null;
		try {
			clearLastState();
			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()));
			cleanupMarkers(this.currentproject);
			IPluginModelBase currentModel = getCurrentModel();
			if (currentModel != null) {
				localMonitor.subTask(BuilderMessages.building_workspace_profile);

				// Compatibility checks
				IApiComponent apiComponent = wsprofile.getApiComponent(id);
				if(apiComponent != null) {
					this.analyzer.analyzeComponent(this.buildstate, null, null, baseline, apiComponent, null, null, localMonitor.newChild(1));
					updateMonitor(localMonitor, 1);
					createMarkers();
					updateMonitor(localMonitor, 1);

	 */
	protected void createMarkers() {
		try {
			this.currentproject.deleteMarkers(IApiMarkerConstants.VERSION_NUMBERING_PROBLEM_MARKER, true, IResource.DEPTH_INFINITE);
			this.currentproject.deleteMarkers(IApiMarkerConstants.DEFAULT_API_BASELINE_PROBLEM_MARKER, true, IResource.DEPTH_ZERO);
			this.currentproject.deleteMarkers(IApiMarkerConstants.API_COMPONENT_RESOLUTION_PROBLEM_MARKER, true, IResource.DEPTH_ZERO);
		} catch (CoreException e) {
			ApiPlugin.log(e);
		}
		IApiProblem[] problems = this.analyzer.getProblems();
		String type = null;
		for(int i = 0; i < problems.length; i++) {
			int category = problems[i].getCategory();

							IApiMarkerConstants.MARKER_ATTR_PROBLEM_ID},
					new Object[] {
							problem.getMessage(),
							new Integer(ApiPlugin.getDefault().getSeverityLevel(ApiProblemFactory.getProblemSeverityId(problem), this.currentproject)),
							new Integer(line),
							new Integer(problem.getCharStart()),
							new Integer(problem.getCharEnd()),

		if (resourcePath == null) {
			return null;
		}
		IResource resource = currentproject.findMember(new Path(resourcePath));
		if(resource == null) {
			return null;
		}

	 * @param ticks
	 * @throws OperationCanceledException
	 */
	void updateMonitor(IProgressMonitor monitor, int ticks) throws OperationCanceledException {
		if(monitor != null) {
			monitor.worked(ticks);
			if (monitor.isCanceled()) {

		}
	}
	
	/**
	 * Builds an API delta using the default profile (from the workspace settings and the current
	 * workspace profile
	 * @param state
	 * @param monitor
	 */
	private void build(final State state, IApiBaseline baseline, IProgressMonitor monitor) throws CoreException {
		IApiBaseline wsprofile = null;
		try {
			clearLastState(); // so if the build fails, a full build will be triggered
			int typesToCheckSize = fTypesToCheck.size();
			SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 2 + (typesToCheckSize != 0 ? 3 : 0));
			localMonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_finding_affected_source_files, fCurrentProject.getName()));
			updateMonitor(localMonitor, 0);
			collectAffectedSourceFiles(state, fTypesToCheck);
			updateMonitor(localMonitor, 1);
			if (typesToCheckSize != 0) {
				IPluginModelBase currentModel = getCurrentModel();
				if (currentModel != null) {
					wsprofile = getWorkspaceProfile();
					if (wsprofile == null) {
						if (DEBUG) {
							System.err.println("Could not retrieve a workspace profile"); //$NON-NLS-1$
						}
						return;
					}
					String id = currentModel.getBundleDescription().getSymbolicName();
					IApiComponent apiComponent = wsprofile.getApiComponent(id);
					if(apiComponent == null) {
						return;
					}
					List tnames = new ArrayList(typesToCheckSize),
						 cnames = new ArrayList(typesToCheckSize);
					collectAllQualifiedNames(fTypesToCheck, tnames, cnames, localMonitor.newChild(1));
					updateMonitor(localMonitor, 1);
					fAnalyzer.analyzeComponent(fBuildState, 
							null, 
							null, 
							baseline, 
							apiComponent, 
							(String[])tnames.toArray(new String[tnames.size()]), 
							(String[])cnames.toArray(new String[cnames.size()]), 
							localMonitor.newChild(1));
					updateMonitor(localMonitor, 1);
					createMarkers();
					updateMonitor(localMonitor, 1);
				}
			}
		}
		finally {
			if(wsprofile != null) {
				wsprofile.close();
			}
			if(monitor != null) {
				monitor.done();
			}
		}
	}
	
	/**
	 * Returns an array of type names, and cleans up markers for the specified resource
	 * @param alltypes the listing of {@link IFile}s to get qualified names from
	 * @param changedtypes the listing of {@link IFile}s that have actually changed (from the {@link IResourceDelta}
	 * @param tnames the list to collect all type names into (including inner member names)
	 * @param cnames the list to collect the changed type names into
	 * @param monitor
	 */
	private void collectAllQualifiedNames(final HashSet alltypes, List tnames, List cnames, final IProgressMonitor monitor) {
		IType[] types = null;
		IFile file = null;
		for (Iterator iterator = alltypes.iterator(); iterator.hasNext(); ) {
			file = (IFile) iterator.next();
			ICompilationUnit unit = (ICompilationUnit) JavaCore.create(file);
			if(!unit.exists()) {
				continue;
			}
			IType type = unit.findPrimaryType();
			if(type == null) {
				continue;
			}
			updateMonitor(monitor, 0);
			cleanupUnsupportedTagMarkers(file);
			updateMonitor(monitor, 0);
			cleanupCompatibilityMarkers(file);
			updateMonitor(monitor, 0);
			cnames.add(type.getFullyQualifiedName());
			try {
				cleanupUsageMarkers(file);
				updateMonitor(monitor, 0);
				types = unit.getAllTypes();
				String tname = null;
				for (int i = 0; i < types.length; i++) {
					IType type2 = types[i];
					if (type2.isMember()) {
						tname = type2.getFullyQualifiedName('$');
					} else {
						tname = type2.getFullyQualifiedName();
					}
					tnames.add(tname);
				}
			} catch (JavaModelException e) {
				ApiPlugin.log(e.getStatus());
			}
			updateMonitor(monitor, 0);
		}
		// inject removed types inside changed type names so that we can properly detect type removal
		for (Iterator iterator = this.fAddedRemovedDeltas.iterator(); iterator.hasNext(); ) {
			IResourceDelta delta = (IResourceDelta) iterator.next();
			if (delta.getKind() != IResourceDelta.REMOVED) continue;
			IResource resource = delta.getResource();
			IPath typePath = resolveJavaPathFromResource(resource);
			if(typePath == null) {
				continue;
			}
			// record removed type names (package + type)
			StringBuffer buffer = new StringBuffer();
			String[] segments = typePath.segments();
			for (int i = 0, max = segments.length; i < max; i++) {
				if (i > 0) {
					buffer.append('.');
				}
				buffer.append(segments[i]);
			}
			cnames.add(String.valueOf(buffer));
		}
		// clean up markers on added deltas
		if (!this.fAddedRemovedDeltas.isEmpty()) {
			IResource manifestFile = Util.getManifestFile(this.fCurrentProject);
			if (manifestFile != null) {
				try {
					IMarker[] markers = manifestFile.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);
					for (int i = 0, max = markers.length; i < max; i++) {
						IMarker marker = markers[i];
						String typeName = marker.getAttribute(IApiMarkerConstants.MARKER_ATTR_PROBLEM_TYPE_NAME, null);
						if (typeName != null) {
							for (Iterator iterator = this.fAddedRemovedDeltas.iterator(); iterator.hasNext(); ) {
								IResourceDelta delta = (IResourceDelta) iterator.next();
								if (delta.getKind() != IResourceDelta.ADDED) continue;
								ICompilationUnit unit = (ICompilationUnit) JavaCore.create(delta.getResource());
								if(!unit.exists()) {
									continue;
								}
								IType type = unit.findPrimaryType();
								if(type == null) {
									continue;
								}
								if (typeName.equals(type.getFullyQualifiedName())) {
									marker.delete();
									return;
								} else {
									// check secondary types
									try {
										types = unit.getAllTypes();
										for (int j = 0; j < types.length; j++) {
											IType type2 = types[i];
											String fullyQualifiedName = null;
											if (type2.isMember()) {
												fullyQualifiedName = type2.getFullyQualifiedName('$');
											} else {
												fullyQualifiedName = type2.getFullyQualifiedName();
											}
											if (typeName.equals(fullyQualifiedName)) {
												marker.delete();
												return;
											}
										}
									} catch (JavaModelException e) {
										ApiPlugin.log(e.getStatus());
									}
								}
							}
						}
					}
				} catch (CoreException e) {
					ApiPlugin.log(e.getStatus());
				}
			}
		}
		IResource resource = fCurrentProject.findMember(MANIFEST_PATH);
		if (resource != null) {
			try {
				IMarker[] markers = resource.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
				loop: for (int i = 0, max = markers.length; i < max; i++) {
					IMarker marker = markers[i];
					String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
					for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
						String typeName = (String) iterator.next();
						if (typeName.equals(typeNameFromMarker)) {
							marker.delete();
							continue loop;
						}
					}
				}
				markers = resource.findMarkers(IApiMarkerConstants.SINCE_TAGS_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
				loop: for (int i = 0, max = markers.length; i < max; i++) {
					IMarker marker = markers[i];
					String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
					for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
						String typeName = (String) iterator.next();
						if (typeName.equals(typeNameFromMarker)) {
							marker.delete();
							continue loop;
						}
					}
				}
			} catch (CoreException e) {
				ApiPlugin.log(e);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.resources.IncrementalProjectBuilder#clean(org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void clean(IProgressMonitor monitor) throws CoreException {
		this.currentproject = getProject();
		SubMonitor localmonitor = SubMonitor.convert(monitor, MessageFormat.format(BuilderMessages.CleaningAPIDescription, new String[] {currentproject.getName()}), 2);
		try {
			// clean up all existing markers
			cleanupUsageMarkers(this.currentproject);
			cleanupCompatibilityMarkers(this.currentproject);
			cleanupUnsupportedTagMarkers(this.currentproject);
			this.currentproject.deleteMarkers(IApiMarkerConstants.UNUSED_FILTER_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);
			updateMonitor(localmonitor, 1);
			//clean up the .api_settings
			cleanupApiDescription(this.currentproject);
			updateMonitor(localmonitor, 1);
		}
		finally {

			ApiDescriptionManager.getDefault().clean(JavaCore.create(project), true, false);
		}
	}
	/**
	 * Collects the complete set of affected source files from the current project context based on the current JDT build state.
	 * 
	 * @param state
	 */
	private void collectAffectedSourceFiles(State state, Set typesToCheck) {
		// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
		char[][][] internedQualifiedNames = ReferenceCollection.internQualifiedNames(fPackages);
		// if a well known qualified name was found then we can skip over these
		if (internedQualifiedNames.length < fPackages.elementSize) {
			internedQualifiedNames = null;
		}
		char[][] internedSimpleNames = ReferenceCollection.internSimpleNames(fTypes, true);
		// if a well known name was found then we can skip over these
		if (internedSimpleNames.length < fTypes.elementSize) {
			internedSimpleNames = null;
		}
		Object[] keyTable = state.getReferences().keyTable;
		Object[] valueTable = state.getReferences().valueTable;
		next : for (int i = 0, l = valueTable.length; i < l; i++) {
			String typeLocator = (String) keyTable[i];
			if (typeLocator != null) {
				ReferenceCollection refs = (ReferenceCollection) valueTable[i];
				if (refs.includes(internedQualifiedNames, internedSimpleNames, null)) {
					IFile file = fCurrentProject.getFile(typeLocator);
					if (file == null) {
						continue next;
					}
					if (DEBUG) {
						System.out.println("  adding affected source file " + typeLocator); //$NON-NLS-1$
					}
					typesToCheck.add(file);
				}
			}
		}
	}
	
	

	/**
	 * Finds affected source files for a resource that has changed that either contains class files or is itself a class file
	 * @param binaryDelta
	 */
	private void findAffectedSourceFiles(IResourceDelta binaryDelta) {
		IResource resource = binaryDelta.getResource();
		if(resource.getType() == IResource.FILE) {
			if (Util.isClassFile(resource.getName())) {
				switch (binaryDelta.getKind()) {
					case IResourceDelta.REMOVED :
						fAddedRemovedDeltas.add(binaryDelta);
						//$FALL-THROUGH$
					case IResourceDelta.ADDED : {
						IPath typePath = resolveJavaPathFromResource(resource);
						if(typePath == null) {
							return;
						}
						if (DEBUG) {
							System.out.println("Found added/removed class file " + typePath); //$NON-NLS-1$
						}
						addDependentsOf(typePath);
						return;
					}
					case IResourceDelta.CHANGED : {
						if ((binaryDelta.getFlags() & IResourceDelta.CONTENT) == 0) {
							return; // skip it since it really isn't changed
						}
						IPath typePath = resolveJavaPathFromResource(resource);
						if(typePath == null) {
							return;
						}
						if (DEBUG) {
							System.out.println("Found changed class file " + typePath); //$NON-NLS-1$
						}
						addDependentsOf(typePath);
					}
				}
				return;
			}
		}
	}

	/**
	 * @return the current {@link IPluginModelBase} based on the current project for this builder
	 */
	IPluginModelBase getCurrentModel() {
		IPluginModelBase[] workspaceModels = PluginRegistry.getWorkspaceModels();
		IPath location = this.currentproject.getLocation();
		IPluginModelBase currentModel = null;
		BundleDescription desc = null;
		loop: for (int i = 0, max = workspaceModels.length; i < max; i++) {

	 */
	private IResourceDelta[] getDeltas(IProject[] projects) {
		if(DEBUG) {
			System.out.println("Searching for deltas for build of project: "+this.currentproject.getName()); //$NON-NLS-1$
		}
		ArrayList deltas = new ArrayList();
		IResourceDelta delta = getDelta(this.currentproject);
		if(delta != null) {
			if (DEBUG) {
				System.out.println("Found a delta: " + delta); //$NON-NLS-1$

	 */
	private IProject[] getRequiredProjects(boolean includebinaries) throws CoreException {
		IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
		if (this.currentproject == null || workspaceRoot == null) { 
			return new IProject[0];
		}
		ArrayList projects = new ArrayList();
		try {
			IJavaProject javaProject = JavaCore.create(this.currentproject);
			HashSet blocations = new HashSet();
			blocations.add(javaProject.getOutputLocation());
			projecttooutputlocations.put(this.currentproject, blocations);
			IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
			for (int i = 0, l = entries.length; i < l; i++) {
				IClasspathEntry entry = entries[i];

								}
							}
						}
						this.projecttooutputlocations.put(p, bins);
					}
				}
			}

	/**
	 * @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 project
	 * @return the output paths for the given project or <code>null</code>
	 */
	HashSet getProjectOutputPaths(IProject project) {
		return (HashSet) this.projecttooutputlocations.get(project);
	}
	
	/**
	 * Returns is the given classpath entry is optional or not
	 * @param entry

		}
		return false;
	}

	/**
	 * Resolves the java path from the given resource
	 * @param resource
	 * @return the resolved path or <code>null</code> if the resource is not part of the java model
	 */
	private IPath resolveJavaPathFromResource(IResource resource) {
		IJavaElement element = JavaCore.create(resource);
		if(element != null) {
			switch(element.getElementType()) {
				case IJavaElement.CLASS_FILE: {
					org.eclipse.jdt.core.IClassFile classfile = (org.eclipse.jdt.core.IClassFile) element;
					IType type = classfile.getType();
					HashSet paths = (HashSet) fProjectToOutputLocations.get(resource.getProject());
					IPath prefix = null;
					for(Iterator iter = paths.iterator(); iter.hasNext();) {
						prefix = (IPath) iter.next();
						if(prefix.isPrefixOf(type.getPath())) {
							return type.getPath().removeFirstSegments(prefix.segmentCount()).removeFileExtension();
						}
					}
					break;
				}
			}
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return NLS.bind(BuilderMessages.ApiAnalysisBuilder_builder_for_project, this.currentproject.getName());
	}
	
	/**

	/**
	 * 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 {

	/**
	 * 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;
		}

	 * @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$
		}

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

Lines 13-18 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/buildermessages.properties (+1 lines)
13	building_workspace_profile=Building workspace API profile	13	building_workspace_profile=Building workspace API profile
14	checking_api_usage=Checking API use of ''{0}''	14	checking_api_usage=Checking API use of ''{0}''
15	AbstractTypeLeakDetector_vis_type_has_no_api_description=Visible type {0} has no API description	15	AbstractTypeLeakDetector_vis_type_has_no_api_description=Visible type {0} has no API description
		16	ApiAnalysisBuilder_builder_for_project=Builder for project: [{0}]
16	ApiAnalysisBuilder_finding_affected_source_files=Finding affected source in ''{0}''	17	ApiAnalysisBuilder_finding_affected_source_files=Finding affected source in ''{0}''
17	ApiAnalysisBuilder_initializing_analyzer=Initializing analyzer for ''{0}''	18	ApiAnalysisBuilder_initializing_analyzer=Initializing analyzer for ''{0}''
18	ApiProblemFactory_problem_message_not_found=Message not found for id: {0}	19	ApiProblemFactory_problem_message_not_found=Message not found for id: {0}

Lines 56-62 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ApiBaselineManager.java (-2 lines)
56	import org.eclipse.jdt.core.IPackageFragment;	56	import org.eclipse.jdt.core.IPackageFragment;
57	import org.eclipse.jdt.core.IPackageFragmentRoot;	57	import org.eclipse.jdt.core.IPackageFragmentRoot;
58	import org.eclipse.jdt.core.JavaCore;	58	import org.eclipse.jdt.core.JavaCore;
59	import org.eclipse.pde.api.tools.internal.builder.ApiAnalysisBuilder;
60	import org.eclipse.pde.api.tools.internal.model.ApiBaseline;	59	import org.eclipse.pde.api.tools.internal.model.ApiBaseline;
61	import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;	60	import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;
62	import org.eclipse.pde.api.tools.internal.model.StubApiComponent;	61	import org.eclipse.pde.api.tools.internal.model.StubApiComponent;
Lines 880-886 Link Here
880	IJavaProject jp = JavaCore.create(project);	879	IJavaProject jp = JavaCore.create(project);
881	if (jp.exists()) {	880	if (jp.exists()) {
882	ApiDescriptionManager.getDefault().clean(jp, true, true);	881	ApiDescriptionManager.getDefault().clean(jp, true, true);
883	ApiAnalysisBuilder.cleanupMarkers(resource);
884	}	882	}
885	}	883	}
886	} catch (CoreException e) {	884	} catch (CoreException e) {

Lines 139-146 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ApiDescriptionManager.java (-2 / +2 lines)
139	* Cleans the API description for the given project.	139	* Cleans the API description for the given project.
140	*	140	*
141	* @param project	141	* @param project
142	* @param whether to delete the file on disk	142	* @param delete whether to delete the file on disk
143	* @param whether to remove the cached API description	143	* @param remove whether to remove the cached API description
144	*/	144	*/
145	public synchronized void clean(IJavaProject project, boolean delete, boolean remove) {	145	public synchronized void clean(IJavaProject project, boolean delete, boolean remove) {
146	ProjectApiDescription desc = null;	146	ProjectApiDescription desc = null;




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.api.tools.internal.builder;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
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;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.core.plugin.IPluginModelBase;

/**
 * Used to incrementally build changed Java types
 * 
 * @since 3.5
 */
public class IncrementalApiBuilder {

	/**
	 * Visits a resource delta to determine if the changes have been made that might required a rebuild:
	 * - modification to the manifest file
	 * - removal of the .api_filter file
	 */
	class ResourceDeltaVisitor implements IResourceDeltaVisitor {
		IProject[] projects;
		public ResourceDeltaVisitor(IProject[] projects) {
			this.projects = projects;
		}
		private boolean fRequireFullBuild = false;

		/**
		 * Returns whether a full build should be run.
		 * 
		 * @return whether a full build should be run
		 */
		boolean shouldRunFullBuild() {
			return fRequireFullBuild;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
		 */
		public boolean visit(IResourceDelta delta) throws CoreException {
			switch (delta.getResource().getType()) {
				case IResource.ROOT:
				case IResource.PROJECT:
					return !fRequireFullBuild;
				case IResource.FOLDER:
					return !fRequireFullBuild; 
				case IResource.FILE:
					IResource resource = delta.getResource();
					String fileName = resource.getName();
					if (Util.isClassFile(fileName)) {
						findAffectedSourceFiles(delta);
					} else if (Util.isJavaFileName(fileName)) {
						IProject project = resource.getProject();
						if (IncrementalApiBuilder.this.project.equals(project)) {
							if (delta.getKind() == IResourceDelta.ADDED) {
								IncrementalApiBuilder.this.addremovedeltas.add(delta);
							}
							IncrementalApiBuilder.this.changedtypes.add(resource);
						} else if (this.projects != null) {
							loop: for (int i = 0, max = this.projects.length; i < max; i++) {
								if (this.projects[i].equals(project)) {
									IncrementalApiBuilder.this.changedtypes.add(resource);
									break loop;
								}
							}
						}
					} else if (!fRequireFullBuild && IApiCoreConstants.API_FILTERS_XML_NAME.equals(fileName)) {
						switch(delta.getKind()) {
							case IResourceDelta.REMOVED :
							case IResourceDelta.REPLACED :
							case IResourceDelta.CHANGED :
							case IResourceDelta.ADDED :
								fRequireFullBuild = true;
						}
					}
			}
			return false;
		}
	}
	
	State state = null;
	ApiAnalysisBuilder builder = null;
	IProject project = null;
	HashSet changedtypes = new HashSet(16);
	HashSet addremovedeltas = new HashSet(8);
	StringSet typenames = new StringSet(16);
	StringSet packages = new StringSet(16);
	
	
	/**
	 * Constructor
	 * @param project the current project context being built
	 * @param delta the {@link IResourceDelta} from the build framework
	 * @param buildstate the current build state from the {@link org.eclipse.jdt.internal.core.builder.JavaBuilder}
	 */
	public IncrementalApiBuilder(ApiAnalysisBuilder builder) {
		this.builder = builder;
		this.state = null;
	}
	
	/**
	 * Incrementally builds using the {@link org.eclipse.pde.api.tools.internal.provisional.builder.IApiAnalyzer}
	 * from the given {@link ApiAnalysisBuilder}
	 * 
	 * @param baseline
	 * @param deltas
	 * @param monitor
	 * @throws CoreException
	 */
	public void build(IApiBaseline baseline, IResourceDelta[] deltas, IProgressMonitor monitor) throws CoreException {
		this.project = this.builder.getProject();
		SubMonitor localmonitor = SubMonitor.convert(monitor, NLS.bind("API analysis: Incrementally building... {0}", this.project), 10);
		try {
			this.state = (State)JavaModelManager.getJavaModelManager().getLastBuiltState(this.project, localmonitor.newChild(1));
			if(this.state == null) {
				this.builder.buildAll(baseline, localmonitor);
			}
			this.builder.clearLastState();
			//start incremental preparing
			build(this.state, baseline, localmonitor.newChild(1));
		}
		finally {
			if(!localmonitor.isCanceled()) {
				localmonitor.done();
			}
			this.changedtypes.clear();
		}
	}
	
	/**
	 * Collects the complete set of affected source files from the current project context based on the current JDT build state.
	 * 
	 * @param state
	 */
	private void collectAffectedSourceFiles(State state, Set typesToCheck) {
		// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
		char[][][] internedQualifiedNames = ReferenceCollection.internQualifiedNames(this.packages);
		// if a well known qualified name was found then we can skip over these
		if (internedQualifiedNames.length < this.packages.elementSize) {
			internedQualifiedNames = null;
		}
		char[][] internedSimpleNames = ReferenceCollection.internSimpleNames(this.typenames, true);
		// if a well known name was found then we can skip over these
		if (internedSimpleNames.length < this.typenames.elementSize) {
			internedSimpleNames = null;
		}
		Object[] keyTable = state.getReferences().keyTable;
		Object[] valueTable = state.getReferences().valueTable;
		next : for (int i = 0, l = valueTable.length; i < l; i++) {
			String typeLocator = (String) keyTable[i];
			if (typeLocator != null) {
				ReferenceCollection refs = (ReferenceCollection) valueTable[i];
				if (refs.includes(internedQualifiedNames, internedSimpleNames, null)) {
					IFile file = this.project.getFile(typeLocator);
					if (file == null) {
						continue next;
					}
					if (ApiAnalysisBuilder.DEBUG) {
						System.out.println("  adding affected source file " + typeLocator); //$NON-NLS-1$
					}
					typesToCheck.add(file);
				}
			}
		}
	}
	
	/**
	 * Finds affected source files for a resource that has changed that either contains class files or is itself a class file
	 * @param binaryDelta
	 */
	private void findAffectedSourceFiles(IResourceDelta binaryDelta) {
		IResource resource = binaryDelta.getResource();
		if(resource.getType() == IResource.FILE) {
			if (Util.isClassFile(resource.getName())) {
				switch (binaryDelta.getKind()) {
					case IResourceDelta.REMOVED :
						//fAddedRemovedDeltas.add(binaryDelta);
						//$FALL-THROUGH$
					case IResourceDelta.ADDED : {
						IPath typePath = resolveJavaPathFromResource(resource);
						if(typePath == null) {
							return;
						}
						if (ApiAnalysisBuilder.DEBUG) {
							System.out.println("Found added/removed class file " + typePath); //$NON-NLS-1$
						}
						addDependentsOf(typePath);
						return;
					}
					case IResourceDelta.CHANGED : {
						if ((binaryDelta.getFlags() & IResourceDelta.CONTENT) == 0) {
							return; // skip it since it really isn't changed
						}
						IPath typePath = resolveJavaPathFromResource(resource);
						if(typePath == null) {
							return;
						}
						if (ApiAnalysisBuilder.DEBUG) {
							System.out.println("Found changed class file " + typePath); //$NON-NLS-1$
						}
						addDependentsOf(typePath);
					}
				}
				return;
			}
		}
	}
	
	/**
	 * Adds a type to search for dependents of in considered projects for an incremental build
	 * 
	 * @param path
	 */
	void addDependentsOf(IPath path) {
		// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
		path = path.setDevice(null);
		String packageName = path.removeLastSegments(1).toString();
		String typeName = path.lastSegment();
		int memberIndex = typeName.indexOf('$');
		if (memberIndex > 0) {
			typeName = typeName.substring(0, memberIndex);
		}
		if (this.typenames.add(typeName) && this.packages.add(packageName) && ApiAnalysisBuilder.DEBUG) {
			System.out.println("  will look for dependents of " + typeName + " in " + packageName); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	
	/**
	 * Builds an API delta using the default profile (from the workspace settings and the current
	 * workspace profile
	 * @param state
	 * @param monitor
	 */
	private void build(final State state, IApiBaseline baseline, IProgressMonitor monitor) throws CoreException {
		IApiBaseline wsprofile = null;
		try {
			int typesToCheckSize = this.changedtypes.size();
			SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 2 + (typesToCheckSize != 0 ? 3 : 0));
			localMonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_finding_affected_source_files, this.project.getName()));
			this.builder.updateMonitor(localMonitor, 0);
			collectAffectedSourceFiles(state, this.changedtypes);
			this.builder.updateMonitor(localMonitor, 1);
			if (typesToCheckSize != 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 apiComponent = wsprofile.getApiComponent(id);
					if(apiComponent == null) {
						return;
					}
					List tnames = new ArrayList(typesToCheckSize),
						 cnames = new ArrayList(typesToCheckSize);
					collectAllQualifiedNames(this.changedtypes, tnames, cnames, localMonitor.newChild(1));
					this.builder.updateMonitor(localMonitor, 1);
					this.builder.getAnalyzer().analyzeComponent(null, 
							null, 
							null, 
							baseline, 
							apiComponent, 
							(String[])tnames.toArray(new String[tnames.size()]), 
							(String[])cnames.toArray(new String[cnames.size()]), 
							localMonitor.newChild(1));
					this.builder.updateMonitor(localMonitor, 1);
					this.builder.createMarkers();
					this.builder.updateMonitor(localMonitor, 1);
				}
			}
		}
		finally {
			if(wsprofile != null) {
				wsprofile.close();
			}
			if(monitor != null) {
				monitor.done();
			}
		}
	}
	
	/**
	 * Returns an array of type names, and cleans up markers for the specified resource
	 * @param alltypes the listing of {@link IFile}s to get qualified names from
	 * @param changedtypes the listing of {@link IFile}s that have actually changed (from the {@link IResourceDelta}
	 * @param tnames the list to collect all type names into (including inner member names)
	 * @param cnames the list to collect the changed type names into
	 * @param monitor
	 */
	private void collectAllQualifiedNames(final HashSet alltypes, List tnames, List cnames, final IProgressMonitor monitor) {
		IType[] types = null;
		IFile file = null;
		for (Iterator iterator = alltypes.iterator(); iterator.hasNext(); ) {
			file = (IFile) iterator.next();
			ICompilationUnit unit = (ICompilationUnit) JavaCore.create(file);
			if(!unit.exists()) {
				continue;
			}
			IType type = unit.findPrimaryType();
			if(type == null) {
				continue;
			}
			this.builder.updateMonitor(monitor, 0);
			this.builder.cleanupUnsupportedTagMarkers(file);
			this.builder.updateMonitor(monitor, 0);
			this.builder.cleanupCompatibilityMarkers(file);
			this.builder.updateMonitor(monitor, 0);
			cnames.add(type.getFullyQualifiedName());
			try {
				this.builder.cleanupUsageMarkers(file);
				this.builder.updateMonitor(monitor, 0);
				types = unit.getAllTypes();
				String tname = null;
				for (int i = 0; i < types.length; i++) {
					IType type2 = types[i];
					if (type2.isMember()) {
						tname = type2.getFullyQualifiedName('$');
					} else {
						tname = type2.getFullyQualifiedName();
					}
					tnames.add(tname);
				}
			} catch (JavaModelException e) {
				ApiPlugin.log(e.getStatus());
			}
			this.builder.updateMonitor(monitor, 0);
		}
		// inject removed types inside changed type names so that we can properly detect type removal
		for (Iterator iterator = this.addremovedeltas.iterator(); iterator.hasNext(); ) {
			IResourceDelta delta = (IResourceDelta) iterator.next();
			if (delta.getKind() != IResourceDelta.REMOVED) continue;
			IResource resource = delta.getResource();
			IPath typePath = resolveJavaPathFromResource(resource);
			if(typePath == null) {
				continue;
			}
			// record removed type names (package + type)
			StringBuffer buffer = new StringBuffer();
			String[] segments = typePath.segments();
			for (int i = 0, max = segments.length; i < max; i++) {
				if (i > 0) {
					buffer.append('.');
				}
				buffer.append(segments[i]);
			}
			cnames.add(String.valueOf(buffer));
		}
		// clean up markers on added deltas
		if (!this.addremovedeltas.isEmpty()) {
			IResource manifestFile = Util.getManifestFile(this.project);
			if (manifestFile != null) {
				try {
					IMarker[] markers = manifestFile.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);
					for (int i = 0, max = markers.length; i < max; i++) {
						IMarker marker = markers[i];
						String typeName = marker.getAttribute(IApiMarkerConstants.MARKER_ATTR_PROBLEM_TYPE_NAME, null);
						if (typeName != null) {
							for (Iterator iterator = this.addremovedeltas.iterator(); iterator.hasNext(); ) {
								IResourceDelta delta = (IResourceDelta) iterator.next();
								if (delta.getKind() != IResourceDelta.ADDED) {
									continue;
								}
								ICompilationUnit unit = (ICompilationUnit) JavaCore.create(delta.getResource());
								if(!unit.exists()) {
									continue;
								}
								IType type = unit.findPrimaryType();
								if(type == null) {
									continue;
								}
								if (typeName.equals(type.getFullyQualifiedName())) {
									marker.delete();
									return;
								} else {
									// check secondary types
									try {
										types = unit.getAllTypes();
										for (int j = 0; j < types.length; j++) {
											IType type2 = types[i];
											String fullyQualifiedName = null;
											if (type2.isMember()) {
												fullyQualifiedName = type2.getFullyQualifiedName('$');
											} else {
												fullyQualifiedName = type2.getFullyQualifiedName();
											}
											if (typeName.equals(fullyQualifiedName)) {
												marker.delete();
												return;
											}
										}
									} catch (JavaModelException e) {
										ApiPlugin.log(e.getStatus());
									}
								}
							}
						}
					}
				} catch (CoreException e) {
					ApiPlugin.log(e.getStatus());
				}
			}
		}
		IResource resource = this.project.findMember(ApiAnalysisBuilder.MANIFEST_PATH);
		if (resource != null) {
			try {
				IMarker[] markers = resource.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
				loop: for (int i = 0, max = markers.length; i < max; i++) {
					IMarker marker = markers[i];
					String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
					for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
						String typeName = (String) iterator.next();
						if (typeName.equals(typeNameFromMarker)) {
							marker.delete();
							continue loop;
						}
					}
				}
				markers = resource.findMarkers(IApiMarkerConstants.SINCE_TAGS_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
				loop: for (int i = 0, max = markers.length; i < max; i++) {
					IMarker marker = markers[i];
					String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
					for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
						String typeName = (String) iterator.next();
						if (typeName.equals(typeNameFromMarker)) {
							marker.delete();
							continue loop;
						}
					}
				}
			} catch (CoreException e) {
				ApiPlugin.log(e);
			}
		}
	}
	
	/**
	 * Resolves the java path from the given resource
	 * @param resource
	 * @return the resolved path or <code>null</code> if the resource is not part of the java model
	 */
	IPath resolveJavaPathFromResource(IResource resource) {
		IJavaElement element = JavaCore.create(resource);
		if(element != null) {
			switch(element.getElementType()) {
				case IJavaElement.CLASS_FILE: {
					org.eclipse.jdt.core.IClassFile classfile = (org.eclipse.jdt.core.IClassFile) element;
					IType type = classfile.getType();
					HashSet paths = this.builder.getProjectOutputPaths(resource.getProject());
					if(paths == null) {
						return null;
					}
					IPath prefix = null;
					for(Iterator iter = paths.iterator(); iter.hasNext();) {
						prefix = (IPath) iter.next();
						if(prefix.isPrefixOf(type.getPath())) {
							return type.getPath().removeFirstSegments(prefix.segmentCount()).removeFileExtension();
						}
					}
					break;
				}
			}
		}
		return null;
	}
}

Return to bug 233643

Lines 301-307 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BaseApiAnalyzer.java (-4 / +4 lines)
301	}	301	}
302	}	302	}
303	if (changedTypes != null) {	303	if (changedTypes != null) {
304	// check the ones not already checked as part of typenames check	304	// check the ones not already checked as part of type names check
305	for (int i = 0; i < changedTypes.length; i++) {	305	for (int i = 0; i < changedTypes.length; i++) {
306	String typeName = changedTypes[i];	306	String typeName = changedTypes[i];
307	if (typeNamesSet == null \|\| !typeNamesSet.remove(typeName)) {	307	if (typeNamesSet == null \|\| !typeNamesSet.remove(typeName)) {
Lines 1550-1556 Link Here
1550	Util.EMPTY_STRING);	1550	Util.EMPTY_STRING);
1551	}	1551	}
1552	}	1552	}
1553	// analyse version of required components	1553	// analyze version of required components
1554	ReexportedBundleVersionInfo info = null;	1554	ReexportedBundleVersionInfo info = null;
1555	if (problem != null) {	1555	if (problem != null) {
1556	switch (problem.getKind()) {	1556	switch (problem.getKind()) {
Lines 1580-1586 Link Here
1580	}	1580	}
1581	break;	1581	break;
1582	case IApiProblem.MINOR_VERSION_CHANGE :	1582	case IApiProblem.MINOR_VERSION_CHANGE :
1583	// check if there is a version change required due to reexported bundles	1583	// check if there is a version change required due to re-exported bundles
1584	info = checkBundleVersionsOfReexportedBundles(reference, component);	1584	info = checkBundleVersionsOfReexportedBundles(reference, component);
1585	if (info != null) {	1585	if (info != null) {
1586	switch(info.kind) {	1586	switch(info.kind) {
Lines 1602-1608 Link Here
1602	}	1602	}
1603	break;	1603	break;
1604	case IApiProblem.MINOR_VERSION_CHANGE_NO_NEW_API :	1604	case IApiProblem.MINOR_VERSION_CHANGE_NO_NEW_API :
1605	// check if there is a version change required due to reexported bundles	1605	// check if there is a version change required due to re-exported bundles
1606	info = checkBundleVersionsOfReexportedBundles(reference, component);	1606	info = checkBundleVersionsOfReexportedBundles(reference, component);
1607	if (info != null) {	1607	if (info != null) {
1608	switch(info.kind) {	1608	switch(info.kind) {

Added Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/IncrementalApiBuilder.java (+507 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.api.tools.internal.builder;
12
13	import java.util.ArrayList;
14	import java.util.HashSet;
15	import java.util.Iterator;
16	import java.util.List;
17	import java.util.Set;
18
19	import org.eclipse.core.resources.IFile;
20	import org.eclipse.core.resources.IMarker;
21	import org.eclipse.core.resources.IProject;
22	import org.eclipse.core.resources.IResource;
23	import org.eclipse.core.resources.IResourceDelta;
24	import org.eclipse.core.resources.IResourceDeltaVisitor;
25	import org.eclipse.core.runtime.CoreException;
26	import org.eclipse.core.runtime.IPath;
27	import org.eclipse.core.runtime.IProgressMonitor;
28	import org.eclipse.core.runtime.SubMonitor;
29	import org.eclipse.jdt.core.ICompilationUnit;
30	import org.eclipse.jdt.core.IJavaElement;
31	import org.eclipse.jdt.core.IType;
32	import org.eclipse.jdt.core.JavaCore;
33	import org.eclipse.jdt.core.JavaModelException;
34	import org.eclipse.jdt.internal.core.JavaModelManager;
35	import org.eclipse.jdt.internal.core.builder.ReferenceCollection;
36	import org.eclipse.jdt.internal.core.builder.State;
37	import org.eclipse.jdt.internal.core.builder.StringSet;
38	import org.eclipse.osgi.util.NLS;
39	import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
40	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
41	import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;
42	import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
43	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
44	import org.eclipse.pde.api.tools.internal.util.Util;
45	import org.eclipse.pde.core.plugin.IPluginModelBase;
46
47	/**
48	* Used to incrementally build changed Java types
49	*
50	* @since 3.5
51	*/
52	public class IncrementalApiBuilder {
53
54	/**
55	* Visits a resource delta to determine if the changes have been made that might required a rebuild:
56	* - modification to the manifest file
57	* - removal of the .api_filter file
58	*/
59	class ResourceDeltaVisitor implements IResourceDeltaVisitor {
60	IProject[] projects;
61	public ResourceDeltaVisitor(IProject[] projects) {
62	this.projects = projects;
63	}
64	private boolean fRequireFullBuild = false;
65
66	/**
67	* Returns whether a full build should be run.
68	*
69	* @return whether a full build should be run
70	*/
71	boolean shouldRunFullBuild() {
72	return fRequireFullBuild;
73	}
74
75	/* (non-Javadoc)
76	* @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
77	*/
78	public boolean visit(IResourceDelta delta) throws CoreException {
79	switch (delta.getResource().getType()) {
80	case IResource.ROOT:
81	case IResource.PROJECT:
82	return !fRequireFullBuild;
83	case IResource.FOLDER:
84	return !fRequireFullBuild;
85	case IResource.FILE:
86	IResource resource = delta.getResource();
87	String fileName = resource.getName();
88	if (Util.isClassFile(fileName)) {
89	findAffectedSourceFiles(delta);
90	} else if (Util.isJavaFileName(fileName)) {
91	IProject project = resource.getProject();
92	if (IncrementalApiBuilder.this.project.equals(project)) {
93	if (delta.getKind() == IResourceDelta.ADDED) {
94	IncrementalApiBuilder.this.addremovedeltas.add(delta);
95	}
96	IncrementalApiBuilder.this.changedtypes.add(resource);
97	} else if (this.projects != null) {
98	loop: for (int i = 0, max = this.projects.length; i < max; i++) {
99	if (this.projects[i].equals(project)) {
100	IncrementalApiBuilder.this.changedtypes.add(resource);
101	break loop;
102	}
103	}
104	}
105	} else if (!fRequireFullBuild && IApiCoreConstants.API_FILTERS_XML_NAME.equals(fileName)) {
106	switch(delta.getKind()) {
107	case IResourceDelta.REMOVED :
108	case IResourceDelta.REPLACED :
109	case IResourceDelta.CHANGED :
110	case IResourceDelta.ADDED :
111	fRequireFullBuild = true;
112	}
113	}
114	}
115	return false;
116	}
117	}
118
119	State state = null;
120	ApiAnalysisBuilder builder = null;
121	IProject project = null;
122	HashSet changedtypes = new HashSet(16);
123	HashSet addremovedeltas = new HashSet(8);
124	StringSet typenames = new StringSet(16);
125	StringSet packages = new StringSet(16);
126
127
128	/**
129	* Constructor
130	* @param project the current project context being built
131	* @param delta the {@link IResourceDelta} from the build framework
132	* @param buildstate the current build state from the {@link org.eclipse.jdt.internal.core.builder.JavaBuilder}
133	*/
134	public IncrementalApiBuilder(ApiAnalysisBuilder builder) {
135	this.builder = builder;
136	this.state = null;
137	}
138
139	/**
140	* Incrementally builds using the {@link org.eclipse.pde.api.tools.internal.provisional.builder.IApiAnalyzer}
141	* from the given {@link ApiAnalysisBuilder}
142	*
143	* @param baseline
144	* @param deltas
145	* @param monitor
146	* @throws CoreException
147	*/
148	public void build(IApiBaseline baseline, IResourceDelta[] deltas, IProgressMonitor monitor) throws CoreException {
149	this.project = this.builder.getProject();
150	SubMonitor localmonitor = SubMonitor.convert(monitor, NLS.bind("API analysis: Incrementally building... {0}", this.project), 10);
151	try {
152	this.state = (State)JavaModelManager.getJavaModelManager().getLastBuiltState(this.project, localmonitor.newChild(1));
153	if(this.state == null) {
154	this.builder.buildAll(baseline, localmonitor);
155	}
156	this.builder.clearLastState();
157	//start incremental preparing
158	build(this.state, baseline, localmonitor.newChild(1));
159	}
160	finally {
161	if(!localmonitor.isCanceled()) {
162	localmonitor.done();
163	}
164	this.changedtypes.clear();
165	}
166	}
167
168	/**
169	* Collects the complete set of affected source files from the current project context based on the current JDT build state.
170	*
171	* @param state
172	*/
173	private void collectAffectedSourceFiles(State state, Set typesToCheck) {
174	// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
175	char[][][] internedQualifiedNames = ReferenceCollection.internQualifiedNames(this.packages);
176	// if a well known qualified name was found then we can skip over these
177	if (internedQualifiedNames.length < this.packages.elementSize) {
178	internedQualifiedNames = null;
179	}
180	char[][] internedSimpleNames = ReferenceCollection.internSimpleNames(this.typenames, true);
181	// if a well known name was found then we can skip over these
182	if (internedSimpleNames.length < this.typenames.elementSize) {
183	internedSimpleNames = null;
184	}
185	Object[] keyTable = state.getReferences().keyTable;
186	Object[] valueTable = state.getReferences().valueTable;
187	next : for (int i = 0, l = valueTable.length; i < l; i++) {
188	String typeLocator = (String) keyTable[i];
189	if (typeLocator != null) {
190	ReferenceCollection refs = (ReferenceCollection) valueTable[i];
191	if (refs.includes(internedQualifiedNames, internedSimpleNames, null)) {
192	IFile file = this.project.getFile(typeLocator);
193	if (file == null) {
194	continue next;
195	}
196	if (ApiAnalysisBuilder.DEBUG) {
197	System.out.println(" adding affected source file " + typeLocator); //$NON-NLS-1$
198	}
199	typesToCheck.add(file);
200	}
201	}
202	}
203	}
204
205	/**
206	* Finds affected source files for a resource that has changed that either contains class files or is itself a class file
207	* @param binaryDelta
208	*/
209	private void findAffectedSourceFiles(IResourceDelta binaryDelta) {
210	IResource resource = binaryDelta.getResource();
211	if(resource.getType() == IResource.FILE) {
212	if (Util.isClassFile(resource.getName())) {
213	switch (binaryDelta.getKind()) {
214	case IResourceDelta.REMOVED :
215	//fAddedRemovedDeltas.add(binaryDelta);
216	//$FALL-THROUGH$
217	case IResourceDelta.ADDED : {
218	IPath typePath = resolveJavaPathFromResource(resource);
219	if(typePath == null) {
220	return;
221	}
222	if (ApiAnalysisBuilder.DEBUG) {
223	System.out.println("Found added/removed class file " + typePath); //$NON-NLS-1$
224	}
225	addDependentsOf(typePath);
226	return;
227	}
228	case IResourceDelta.CHANGED : {
229	if ((binaryDelta.getFlags() & IResourceDelta.CONTENT) == 0) {
230	return; // skip it since it really isn't changed
231	}
232	IPath typePath = resolveJavaPathFromResource(resource);
233	if(typePath == null) {
234	return;
235	}
236	if (ApiAnalysisBuilder.DEBUG) {
237	System.out.println("Found changed class file " + typePath); //$NON-NLS-1$
238	}
239	addDependentsOf(typePath);
240	}
241	}
242	return;
243	}
244	}
245	}
246
247	/**
248	* Adds a type to search for dependents of in considered projects for an incremental build
249	*
250	* @param path
251	*/
252	void addDependentsOf(IPath path) {
253	// the qualifiedStrings are of the form 'p1/p2' & the simpleStrings are just 'X'
254	path = path.setDevice(null);
255	String packageName = path.removeLastSegments(1).toString();
256	String typeName = path.lastSegment();
257	int memberIndex = typeName.indexOf('$');
258	if (memberIndex > 0) {
259	typeName = typeName.substring(0, memberIndex);
260	}
261	if (this.typenames.add(typeName) && this.packages.add(packageName) && ApiAnalysisBuilder.DEBUG) {
262	System.out.println(" will look for dependents of " + typeName + " in " + packageName); //$NON-NLS-1$ //$NON-NLS-2$
263	}
264	}
265
266	/**
267	* Builds an API delta using the default profile (from the workspace settings and the current
268	* workspace profile
269	* @param state
270	* @param monitor
271	*/
272	private void build(final State state, IApiBaseline baseline, IProgressMonitor monitor) throws CoreException {
273	IApiBaseline wsprofile = null;
274	try {
275	int typesToCheckSize = this.changedtypes.size();
276	SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 2 + (typesToCheckSize != 0 ? 3 : 0));
277	localMonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_finding_affected_source_files, this.project.getName()));
278	this.builder.updateMonitor(localMonitor, 0);
279	collectAffectedSourceFiles(state, this.changedtypes);
280	this.builder.updateMonitor(localMonitor, 1);
281	if (typesToCheckSize != 0) {
282	IPluginModelBase currentModel = this.builder.getCurrentModel();
283	if (currentModel != null) {
284	wsprofile = this.builder.getWorkspaceProfile();
285	if (wsprofile == null) {
286	if (ApiAnalysisBuilder.DEBUG) {
287	System.err.println("Could not retrieve a workspace profile"); //$NON-NLS-1$
288	}
289	return;
290	}
291	String id = currentModel.getBundleDescription().getSymbolicName();
292	IApiComponent apiComponent = wsprofile.getApiComponent(id);
293	if(apiComponent == null) {
294	return;
295	}
296	List tnames = new ArrayList(typesToCheckSize),
297	cnames = new ArrayList(typesToCheckSize);
298	collectAllQualifiedNames(this.changedtypes, tnames, cnames, localMonitor.newChild(1));
299	this.builder.updateMonitor(localMonitor, 1);
300	this.builder.getAnalyzer().analyzeComponent(null,
301	null,
302	null,
303	baseline,
304	apiComponent,
305	(String[])tnames.toArray(new String[tnames.size()]),
306	(String[])cnames.toArray(new String[cnames.size()]),
307	localMonitor.newChild(1));
308	this.builder.updateMonitor(localMonitor, 1);
309	this.builder.createMarkers();
310	this.builder.updateMonitor(localMonitor, 1);
311	}
312	}
313	}
314	finally {
315	if(wsprofile != null) {
316	wsprofile.close();
317	}
318	if(monitor != null) {
319	monitor.done();
320	}
321	}
322	}
323
324	/**
325	* Returns an array of type names, and cleans up markers for the specified resource
326	* @param alltypes the listing of {@link IFile}s to get qualified names from
327	* @param changedtypes the listing of {@link IFile}s that have actually changed (from the {@link IResourceDelta}
328	* @param tnames the list to collect all type names into (including inner member names)
329	* @param cnames the list to collect the changed type names into
330	* @param monitor
331	*/
332	private void collectAllQualifiedNames(final HashSet alltypes, List tnames, List cnames, final IProgressMonitor monitor) {
333	IType[] types = null;
334	IFile file = null;
335	for (Iterator iterator = alltypes.iterator(); iterator.hasNext(); ) {
336	file = (IFile) iterator.next();
337	ICompilationUnit unit = (ICompilationUnit) JavaCore.create(file);
338	if(!unit.exists()) {
339	continue;
340	}
341	IType type = unit.findPrimaryType();
342	if(type == null) {
343	continue;
344	}
345	this.builder.updateMonitor(monitor, 0);
346	this.builder.cleanupUnsupportedTagMarkers(file);
347	this.builder.updateMonitor(monitor, 0);
348	this.builder.cleanupCompatibilityMarkers(file);
349	this.builder.updateMonitor(monitor, 0);
350	cnames.add(type.getFullyQualifiedName());
351	try {
352	this.builder.cleanupUsageMarkers(file);
353	this.builder.updateMonitor(monitor, 0);
354	types = unit.getAllTypes();
355	String tname = null;
356	for (int i = 0; i < types.length; i++) {
357	IType type2 = types[i];
358	if (type2.isMember()) {
359	tname = type2.getFullyQualifiedName('$');
360	} else {
361	tname = type2.getFullyQualifiedName();
362	}
363	tnames.add(tname);
364	}
365	} catch (JavaModelException e) {
366	ApiPlugin.log(e.getStatus());
367	}
368	this.builder.updateMonitor(monitor, 0);
369	}
370	// inject removed types inside changed type names so that we can properly detect type removal
371	for (Iterator iterator = this.addremovedeltas.iterator(); iterator.hasNext(); ) {
372	IResourceDelta delta = (IResourceDelta) iterator.next();
373	if (delta.getKind() != IResourceDelta.REMOVED) continue;
374	IResource resource = delta.getResource();
375	IPath typePath = resolveJavaPathFromResource(resource);
376	if(typePath == null) {
377	continue;
378	}
379	// record removed type names (package + type)
380	StringBuffer buffer = new StringBuffer();
381	String[] segments = typePath.segments();
382	for (int i = 0, max = segments.length; i < max; i++) {
383	if (i > 0) {
384	buffer.append('.');
385	}
386	buffer.append(segments[i]);
387	}
388	cnames.add(String.valueOf(buffer));
389	}
390	// clean up markers on added deltas
391	if (!this.addremovedeltas.isEmpty()) {
392	IResource manifestFile = Util.getManifestFile(this.project);
393	if (manifestFile != null) {
394	try {
395	IMarker[] markers = manifestFile.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE);
396	for (int i = 0, max = markers.length; i < max; i++) {
397	IMarker marker = markers[i];
398	String typeName = marker.getAttribute(IApiMarkerConstants.MARKER_ATTR_PROBLEM_TYPE_NAME, null);
399	if (typeName != null) {
400	for (Iterator iterator = this.addremovedeltas.iterator(); iterator.hasNext(); ) {
401	IResourceDelta delta = (IResourceDelta) iterator.next();
402	if (delta.getKind() != IResourceDelta.ADDED) {
403	continue;
404	}
405	ICompilationUnit unit = (ICompilationUnit) JavaCore.create(delta.getResource());
406	if(!unit.exists()) {
407	continue;
408	}
409	IType type = unit.findPrimaryType();
410	if(type == null) {
411	continue;
412	}
413	if (typeName.equals(type.getFullyQualifiedName())) {
414	marker.delete();
415	return;
416	} else {
417	// check secondary types
418	try {
419	types = unit.getAllTypes();
420	for (int j = 0; j < types.length; j++) {
421	IType type2 = types[i];
422	String fullyQualifiedName = null;
423	if (type2.isMember()) {
424	fullyQualifiedName = type2.getFullyQualifiedName('$');
425	} else {
426	fullyQualifiedName = type2.getFullyQualifiedName();
427	}
428	if (typeName.equals(fullyQualifiedName)) {
429	marker.delete();
430	return;
431	}
432	}
433	} catch (JavaModelException e) {
434	ApiPlugin.log(e.getStatus());
435	}
436	}
437	}
438	}
439	}
440	} catch (CoreException e) {
441	ApiPlugin.log(e.getStatus());
442	}
443	}
444	}
445	IResource resource = this.project.findMember(ApiAnalysisBuilder.MANIFEST_PATH);
446	if (resource != null) {
447	try {
448	IMarker[] markers = resource.findMarkers(IApiMarkerConstants.COMPATIBILITY_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
449	loop: for (int i = 0, max = markers.length; i < max; i++) {
450	IMarker marker = markers[i];
451	String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
452	for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
453	String typeName = (String) iterator.next();
454	if (typeName.equals(typeNameFromMarker)) {
455	marker.delete();
456	continue loop;
457	}
458	}
459	}
460	markers = resource.findMarkers(IApiMarkerConstants.SINCE_TAGS_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
461	loop: for (int i = 0, max = markers.length; i < max; i++) {
462	IMarker marker = markers[i];
463	String typeNameFromMarker = Util.getTypeNameFromMarker(marker);
464	for (Iterator iterator = tnames.iterator(); iterator.hasNext(); ) {
465	String typeName = (String) iterator.next();
466	if (typeName.equals(typeNameFromMarker)) {
467	marker.delete();
468	continue loop;
469	}
470	}
471	}
472	} catch (CoreException e) {
473	ApiPlugin.log(e);
474	}
475	}
476	}
477
478	/**
479	* Resolves the java path from the given resource
480	* @param resource
481	* @return the resolved path or <code>null</code> if the resource is not part of the java model
482	*/
483	IPath resolveJavaPathFromResource(IResource resource) {
484	IJavaElement element = JavaCore.create(resource);
485	if(element != null) {
486	switch(element.getElementType()) {
487	case IJavaElement.CLASS_FILE: {
488	org.eclipse.jdt.core.IClassFile classfile = (org.eclipse.jdt.core.IClassFile) element;
489	IType type = classfile.getType();
490	HashSet paths = this.builder.getProjectOutputPaths(resource.getProject());
491	if(paths == null) {
492	return null;
493	}
494	IPath prefix = null;
495	for(Iterator iter = paths.iterator(); iter.hasNext();) {
496	prefix = (IPath) iter.next();
497	if(prefix.isPrefixOf(type.getPath())) {
498	return type.getPath().removeFirstSegments(prefix.segmentCount()).removeFileExtension();
499	}
500	}
501	break;
502	}
503	}
504	}
505	return null;
506	}
507	}