Attachment #130342 for bug #233643




		setExpectedMessageArgs(new String[][] {{"interref", "test8"}});
		deployTest("test8", XYZ_PATH, I_PATH, "interref.java", addtag);
	}
	
	/**
	 * Tests adding @noextend AND @noinstantiate tags to a class known to be used 
	 * by another bundle
	 * 
	 *  Uses test9.java and classref.java
	 */
	public void testAddExtendInstantiateRestriction() throws Exception {
		test9(true);
	}
	
	/**
	 * Tests removing @noextend AND @noinstantiate tags to a class known to be used 
	 * by another bundle
	 * 
	 * Uses test9.java and classref.java
	 */
	public void testRemoveExtendInstantiateRestriction() throws Exception {
		test9(false);
	}
	
	private void test9(boolean addtag) throws Exception {
		setExpectedProblemIds(new int[] {
				ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_EXTEND, IApiProblem.NO_FLAGS),
				ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_INSTANTIATE, IApiProblem.NO_FLAGS)
		});
		setExpectedMessageArgs(new String[][] {
					{"classref", "test9"},
					{"classref", "test9"}
				});
		deployTest("test9", XYZ_PATH, C_PATH, "classref.java", addtag);
	}
	
	/**
	 * Tests adding @noextend AND @noimplement tags to an interface known to be used 
	 * by another bundle
	 * 
	 *  Uses test10.java and interref.java
	 */
	public void testAddExtendImplementRestriction() throws Exception {
		test10(true);
	}
	
	/**
	 * Tests removing @noextend AND @noimplement tags to an interface known to be used 
	 * by another bundle
	 * 
	 * Uses test10.java and interref.java
	 */
	public void testRemoveExtendImplementRestriction() throws Exception {
		test10(false);
	}
	
	private void test10(boolean addtag) throws Exception {
		setExpectedProblemIds(new int[] {
				ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_EXTEND, IApiProblem.NO_FLAGS),
				ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_IMPLEMENT, IApiProblem.NO_FLAGS)
		});
		setExpectedMessageArgs(new String[][] {
					{"interref", "test10"},
					{"interref", "clazz"}
				});
		deployTest("test10", XYZ_PATH, I_PATH, "interref.java", addtag);
	}
}




/*******************************************************************************
 * 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 x.y.z;

import i.interref;

/**
 * 
 */
public interface test10 extends interref {

}
class clazz implements interref {
	
}




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

/**
 * 
 */
public interface interref {

}




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

/**
 * @noextend
 * @noinstantiate
 */
public class classref {

}




/*******************************************************************************
 * 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 x.y.z;

import c.classref;

/**
 * 
 */
public class test9 extends classref {

	classref ref = new classref();
}




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

/**
 * @noextend
 * @noimplement
 */
public interface interref {

}




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

/**
 * 
 */
public class classref {

}




					}
				}
				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 / +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;
Lines 32-38 Link Here
32	public static String build_wrongFileFormat;	33	public static String build_wrongFileFormat;
33	public static String build_saveStateComplete;	34	public static String build_saveStateComplete;
34	public static String build_cannotSaveState;	35	public static String build_cannotSaveState;
35	public static String IllegalExtendsProblemDetector_an_anonymous_declaration;
36	public static String undefinedRange;	36	public static String undefinedRange;
37	public static String reportUnsatisfiedConstraint;	37	public static String reportUnsatisfiedConstraint;
38		38




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();
		if (!this.currentproject.isAccessible() || !this.currentproject.hasNature(ApiPlugin.NATURE_ID) || hasBeenBuilt(this.currentproject)) {
			return NO_PROJECTS;
				!fCurrentProject.isAccessible() || 
				!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 : {
					this.buildstate = getLastBuiltState(currentproject);
					if (this.buildstate == null) {
					fBuildState = getLastBuiltState(fCurrentProject);
					if (fBuildState == null) {
						buildAll(baseline, localMonitor.newChild(1));
						break;
					}
					else if(worthDoingFullBuild(projects)) {
						buildAll(baseline, localMonitor.newChild(1));
					}
					IResourceDelta[] deltas = getDeltas(projects);
					if(deltas.length < 1) {
						buildAll(baseline, localMonitor.newChild(1));
					}
					else {	
						IResourceDelta manifest = null;
						IResourceDelta filters = null;
								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);
							}
						}
						ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(reexportedProjects);
						for (int i = 0; i < deltas.length; i++) {
							manifest = deltas[i].findMember(MANIFEST_PATH);
							if(manifest != null) {
								shouldRunFullBuild = true;
								break;
							}
							filters = deltas[i].findMember(FILTER_PATH);
							if(filters != null){
								break;
								System.out.println("Performing full build since MANIFEST.MF was modified"); //$NON-NLS-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));
							} else {
								build(state, baseline, localMonitor.newChild(1));
							}
						}
					}
				}	
				}
			}
			updateMonitor(monitor, 0);
		} catch(CoreException e) {

			}
			ApiPlugin.log(e);
		} finally {
			fTypes.clear();
			fPackages.clear();
			fTypesToCheck.clear();
			fAddedRemovedDeltas.clear();
			fProjectToOutputLocations.clear();
			updateMonitor(monitor, 0);
			if(this.analyzer != null) {
				this.analyzer.dispose();
				this.analyzer = null;
			}
			if(baseline != null) {
				baseline.close();
			}
			if(monitor != null) {
				monitor.done();
			}
			if (this.buildstate != null) {
				for(int i = 0, max = projects.length; i < max; i++) {
					IProject project = projects[i];
					if (Util.isApiProject(project)) {
						this.buildstate.addApiToolingDependentProject(project.getName());
					}
				}
				saveBuiltState(this.currentproject, this.buildstate);
				this.buildstate = null;
			}
		}
		if (DEBUG) {
			System.out.println("Finished build of " + this.currentproject.getName() + " @ " + new Date(System.currentTimeMillis())); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return projects;
	}
	
	private boolean worthDoingFullBuild(IProject[] projects) {
		Set apiToolingDependentProjects = this.buildstate.getApiToolingDependentProjects();
		for (int i = 0, max = projects.length; i < max; i++) {
			IProject currentProject = projects[i];
			if (Util.isApiProject(currentProject)) {

		}
		return false;
	}
	
	/**
	 * 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) {
					getAnalyzer().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 = getAnalyzer().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;
		SubMonitor localMonitor = SubMonitor.convert(monitor, BuilderMessages.api_analysis_on_0, 6);
		try {
			clearLastState(); // so if the build fails, a full build will be triggered
			localMonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_finding_affected_source_files, fCurrentProject.getName()));
			updateMonitor(localMonitor, 0);
			collectAffectedSourceFiles(state, fTypesToCheck);
			updateMonitor(localMonitor, 1);
			final int typesToCheckSize = fTypesToCheck.size();
			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(!localMonitor.isCanceled()) {
				localMonitor.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[] {this.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, true);
		}
	}
	/**
	 * 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$

	}

	/**
	 * Returns the API analyzer to use with this instance of the builder
	 * @return the API analyzer to use
	 */
	protected synchronized IApiAnalyzer getAnalyzer() {
		if(this.analyzer == null) {
			this.analyzer = new BaseApiAnalyzer();
		}
		return this.analyzer;
	}
	
	/**

	 */
	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 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 888-894 Link Here
888	IJavaProject jp = JavaCore.create(project);	887	IJavaProject jp = JavaCore.create(project);
889	if (jp.exists()) {	888	if (jp.exists()) {
890	ApiDescriptionManager.getDefault().clean(jp, true, true);	889	ApiDescriptionManager.getDefault().clean(jp, true, true);
891	ApiAnalysisBuilder.cleanupMarkers(resource);
892	}	890	}
893	}	891	}
894	} catch (CoreException e) {	892	} catch (CoreException e) {




	 * Cleans the API description for the given project.
	 * 
	 * @param project
	 * @param delete whether to delete the file on disk
	 * @param remove whether to remove the cached API description
	 */
	public synchronized void clean(IJavaProject project, boolean delete, boolean remove) {
		ProjectApiDescription desc = null;

					switch (delta.getKind()) {
						case IJavaElementDelta.CHANGED: {
							if ((flags & IJavaElementDelta.F_CONTENT) != 0
									|| (flags & IJavaElementDelta.F_FINE_GRAINED) != 0
									|| (flags & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0){
								if (proj != null) {
									projectChanged(proj);
									return true;

	private static void abort(String message, Throwable exception) throws CoreException {
		IStatus status = new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, message, exception);
		throw new CoreException(status);
	}

}

Lines 75-78 Link Here

(-)src/org/eclipse/pde/api/tools/internal/CompilationUnit.java (+7 lines)
75	}	75	}
76	return new FileInputStream(new File(filepath));	76	return new FileInputStream(new File(filepath));
77	}	77	}
		78
		79	/* (non-Javadoc)
		80	* @see java.lang.Object#toString()
		81	*/
		82	public String toString() {
		83	return getName();
		84	}
78	}	85	}




/*******************************************************************************
 * 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.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
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.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 collect changes that need to be built
	 */
	class ResourceDeltaVisitor implements IResourceDeltaVisitor {
		HashSet projects = null;
		IProject project = null;
		
		/**
		 * Constructor
		 * @param project
		 * @param projects
		 */
		public ResourceDeltaVisitor(IProject project, HashSet projects) {
			this.project = project;
			this.projects = projects;
		}
		/* (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:
				case IResource.FOLDER: {
					return true; 
				}
				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 (this.project.equals(project)) {
							if (delta.getKind() == IResourceDelta.ADDED) {
								IncrementalApiBuilder.this.addremovedeltas.add(delta);
							}
							IncrementalApiBuilder.this.changedtypes.add(resource);
						} 
						else if (this.projects != null && this.projects.contains(project)) {
							IncrementalApiBuilder.this.changedtypes.add(resource);
						}
					}
				}
			}
			return false;
		}
	}

	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;
	}
	
	/**
	 * 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, BuildState buildstate, IProgressMonitor monitor) throws CoreException {
		IProject project = this.builder.getProject();
		SubMonitor localmonitor = SubMonitor.convert(monitor, NLS.bind("API analysis: Incrementally building... {0}", project), 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) {
				depprojects = new HashSet();
				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
				IProject pj = null;
				for (int i = 0, max = projectNames.length; i < max; i++) {
					pj = root.getProject(projectNames[i]);
					if (pj.isAccessible()) {
						// select only projects that don't exist in the reference baseline
						if (baseline != null && baseline.getApiComponent(projectNames[i]) == null) {
							depprojects.add(pj);
						}
					}
				}
			}
			ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(project, depprojects);
			for (int i = 0; i < deltas.length; i++) {
				deltas[i].accept(visitor);
			}
			build(project, state, baseline, buildstate, localmonitor.newChild(1));
		}
		finally {
			if(!localmonitor.isCanceled()) {
				localmonitor.done();
			}
			this.changedtypes.clear();
			this.addremovedeltas.clear();
			this.typenames.clear();
			this.packages.clear();
		}
	}
	
	/**
	 * Builds an API delta using the default profile (from the workspace settings and the current
	 * @param project
	 * workspace profile
	 * @param state
	 * @param monitor
	 */
	private void build(final IProject project, final State state, IApiBaseline baseline, 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();
			this.builder.updateMonitor(localmonitor, 1);
			localmonitor.setWorkRemaining(1+(typesize != 0 ? 5 : 0));
			localmonitor.subTask(NLS.bind(BuilderMessages.ApiAnalysisBuilder_finding_affected_source_files, project.getName()));
			this.builder.updateMonitor(localmonitor, 0);
			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 = wsprofile.getApiComponent(id);
					if(comp == null) {
						return;
					}
					List tnames = new ArrayList(typesize),
						 cnames = new ArrayList(typesize);
					collectAllQualifiedNames(project, this.changedtypes, tnames, cnames, localmonitor.newChild(1));
					this.builder.updateMonitor(localmonitor, 1);
					this.builder.getAnalyzer().analyzeComponent(buildstate, 
							null, 
							null, 
							baseline, 
							comp, 
							(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();
			}
		}
	}
	
	/**
	 * Collects the complete set of affected source files from the current project context based on the current JDT build state.
	 * 
	 * @param project
	 * @param state
	 * @param typesToCheck
	 */
	private void collectAffectedSourceFiles(final IProject project, 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;
		IFile file = null;
		String typeLocator = null;
		next : for (int i = 0, l = valueTable.length; i < l; i++) {
			typeLocator =  (String) keyTable[i];
			if (typeLocator != null) {
				ReferenceCollection refs = (ReferenceCollection) valueTable[i];
				if (refs.includes(internedQualifiedNames, internedSimpleNames, null)) {
					file = 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 :
						this.addremovedeltas.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$
		}
	}
	
	/**
	 * 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 IProject project, 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
		IResourceDelta delta = null;
		for (Iterator iterator = this.addremovedeltas.iterator(); iterator.hasNext(); ) {
			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(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(); ) {
								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 = 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 363-366 Link Here

(-)src/org/eclipse/pde/api/tools/builder/tests/usage/DependentUsageTests.java (+64 lines)
363	setExpectedMessageArgs(new String[][] {{"interref", "test8"}});	363	setExpectedMessageArgs(new String[][] {{"interref", "test8"}});
364	deployTest("test8", XYZ_PATH, I_PATH, "interref.java", addtag);	364	deployTest("test8", XYZ_PATH, I_PATH, "interref.java", addtag);
365	}	365	}
		366
		367	/**
		368	* Tests adding @noextend AND @noinstantiate tags to a class known to be used
		369	* by another bundle
		370	*
		371	* Uses test9.java and classref.java
		372	*/
		373	public void testAddExtendInstantiateRestriction() throws Exception {
		374	test9(true);
		375	}
		376
		377	/**
		378	* Tests removing @noextend AND @noinstantiate tags to a class known to be used
		379	* by another bundle
		380	*
		381	* Uses test9.java and classref.java
		382	*/
		383	public void testRemoveExtendInstantiateRestriction() throws Exception {
		384	test9(false);
		385	}
		386
		387	private void test9(boolean addtag) throws Exception {
		388	setExpectedProblemIds(new int[] {
		389	ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_EXTEND, IApiProblem.NO_FLAGS),
		390	ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_INSTANTIATE, IApiProblem.NO_FLAGS)
		391	});
		392	setExpectedMessageArgs(new String[][] {
		393	{"classref", "test9"},
		394	{"classref", "test9"}
		395	});
		396	deployTest("test9", XYZ_PATH, C_PATH, "classref.java", addtag);
		397	}
		398
		399	/**
		400	* Tests adding @noextend AND @noimplement tags to an interface known to be used
		401	* by another bundle
		402	*
		403	* Uses test10.java and interref.java
		404	*/
		405	public void testAddExtendImplementRestriction() throws Exception {
		406	test10(true);
		407	}
		408
		409	/**
		410	* Tests removing @noextend AND @noimplement tags to an interface known to be used
		411	* by another bundle
		412	*
		413	* Uses test10.java and interref.java
		414	*/
		415	public void testRemoveExtendImplementRestriction() throws Exception {
		416	test10(false);
		417	}
		418
		419	private void test10(boolean addtag) throws Exception {
		420	setExpectedProblemIds(new int[] {
		421	ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_EXTEND, IApiProblem.NO_FLAGS),
		422	ApiProblemFactory.createProblemId(IApiProblem.CATEGORY_USAGE, IElementDescriptor.TYPE, IApiProblem.ILLEGAL_IMPLEMENT, IApiProblem.NO_FLAGS)
		423	});
		424	setExpectedMessageArgs(new String[][] {
		425	{"interref", "test10"},
		426	{"interref", "clazz"}
		427	});
		428	deployTest("test10", XYZ_PATH, I_PATH, "interref.java", addtag);
		429	}
366	}	430	}

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) {

Lines 139-146 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ApiDescriptionManager.java (-5 / +5 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;
Lines 261-267 Link Here
261	switch (delta.getKind()) {	261	switch (delta.getKind()) {
262	case IJavaElementDelta.CHANGED: {	262	case IJavaElementDelta.CHANGED: {
263	if ((flags & IJavaElementDelta.F_CONTENT) != 0	263	if ((flags & IJavaElementDelta.F_CONTENT) != 0
264	\|\| (flags & IJavaElementDelta.F_FINE_GRAINED) != 0) {	264	\|\| (flags & IJavaElementDelta.F_FINE_GRAINED) != 0
		265	\|\| (flags & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0){
265	if (proj != null) {	266	if (proj != null) {
266	projectChanged(proj);	267	projectChanged(proj);
267	return true;	268	return true;
Lines 502-507 Link Here
502	private static void abort(String message, Throwable exception) throws CoreException {	503	private static void abort(String message, Throwable exception) throws CoreException {
503	IStatus status = new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, message, exception);	504	IStatus status = new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, message, exception);
504	throw new CoreException(status);	505	throw new CoreException(status);
505	}	506	}
506
507	}	507	}

Added Link Here

(-)test-builder/usage/dependent/test10/test10.java (+23 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 x.y.z;
12
13	import i.interref;
14
15	/**
16	*
17	*/
18	public interface test10 extends interref {
19
20	}
21	class clazz implements interref {
22
23	}

Added Link Here

(-)test-builder/usage/dependent/test10/withouttag/interref.java (+18 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 i;
12
13	/**
14	*
15	*/
16	public interface interref {
17
18	}

Added Link Here

(-)test-builder/usage/dependent/test9/withtag/classref.java (+19 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 c;
12
13	/**
14	* @noextend
15	* @noinstantiate
16	*/
17	public class classref {
18
19	}

Added Link Here

(-)test-builder/usage/dependent/test9/test9.java (+21 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 x.y.z;
12
13	import c.classref;
14
15	/**
16	*
17	*/
18	public class test9 extends classref {
19
20	classref ref = new classref();
21	}

Lines 13-18 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/buildermessages.properties (-1 / +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 25-31 Link Here
25	build_saveStateComplete = Saved in {0} ms	26	build_saveStateComplete = Saved in {0} ms
26	build_wrongFileFormat = Wrong file format	27	build_wrongFileFormat = Wrong file format
27	build_cannotSaveState = Error saving last build state for project {0}	28	build_cannotSaveState = Error saving last build state for project {0}
28	IllegalExtendsProblemDetector_an_anonymous_declaration=An anonymous declaration
29	ReferenceAnalyzer_analyzing_api_checking_use=Analyzing API: Checking API use	29	ReferenceAnalyzer_analyzing_api_checking_use=Analyzing API: Checking API use
30	ReferenceAnalyzer_analyzing_api=Analyzing API	30	ReferenceAnalyzer_analyzing_api=Analyzing API
31	ReferenceAnalyzer_api_analysis_error=API analysis error	31	ReferenceAnalyzer_api_analysis_error=API analysis error