Attachment #59793 for bug #175243

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/DefaultWorkingCopyOwner.java (-4 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 28-36 Link Here
28	// only one instance can be created	28	// only one instance can be created
29	}	29	}
30		30
31	/**
32	* @deprecated Marked deprecated as it is using deprecated code
33	*/
34	public IBuffer createBuffer(ICompilationUnit workingCopy) {	31	public IBuffer createBuffer(ICompilationUnit workingCopy) {
35	if (this.primaryBufferProvider != null) return this.primaryBufferProvider.createBuffer(workingCopy);	32	if (this.primaryBufferProvider != null) return this.primaryBufferProvider.createBuffer(workingCopy);
36	return super.createBuffer(workingCopy);	33	return super.createBuffer(workingCopy);

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/CompilationUnit.java (-2 / +9 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 68-73 Link Here
68	operation.runOperation(monitor);	68	operation.runOperation(monitor);
69	}	69	}
70	}	70	}
		71	/*
		72	* @see ICompilationUnit#becomeWorkingCopy(IProgressMonitor)
		73	*/
		74	public void becomeWorkingCopy(IProgressMonitor monitor) throws JavaModelException {
		75	IProblemRequestor requestor = this.owner == null ? null : this.owner.getProblemRequestor(this);
		76	becomeWorkingCopy(requestor, monitor);
		77	}
71	protected boolean buildStructure(OpenableElementInfo info, final IProgressMonitor pm, Map newElements, IResource underlyingResource) throws JavaModelException {	78	protected boolean buildStructure(OpenableElementInfo info, final IProgressMonitor pm, Map newElements, IResource underlyingResource) throws JavaModelException {
72		79
73	// check if this compilation unit can be opened	80	// check if this compilation unit can be opened
Lines 1122-1128 Link Here
1122	throws JavaModelException {	1129	throws JavaModelException {
1123	return reconcile(astLevel, forceProblemDetection, false, workingCopyOwner, monitor);	1130	return reconcile(astLevel, forceProblemDetection, false, workingCopyOwner, monitor);
1124	}	1131	}
1125		1132
1126	/**	1133	/**
1127	* @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor)	1134	* @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor)
1128	* @since 3.0	1135	* @since 3.0

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/ReconcileWorkingCopyOperation.java (-21 / +43 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 61-67 Link Here
61	this.enableStatementsRecovery = enableStatementsRecovery;	61	this.enableStatementsRecovery = enableStatementsRecovery;
62	this.workingCopyOwner = workingCopyOwner;	62	this.workingCopyOwner = workingCopyOwner;
63	}	63	}
64		64
65	/**	65	/**
66	* @exception JavaModelException if setting the source	66	* @exception JavaModelException if setting the source
67	* of the original compilation unit fails	67	* of the original compilation unit fails
Lines 76-81 Link Here
76	CompilationUnit workingCopy = getWorkingCopy();	76	CompilationUnit workingCopy = getWorkingCopy();
77	boolean wasConsistent = workingCopy.isConsistent();	77	boolean wasConsistent = workingCopy.isConsistent();
78	IProblemRequestor problemRequestor = workingCopy.getPerWorkingCopyInfo();	78	IProblemRequestor problemRequestor = workingCopy.getPerWorkingCopyInfo();
		79	if (problemRequestor != null) {
		80	problemRequestor = ((JavaModelManager.PerWorkingCopyInfo)problemRequestor).problemRequestor;
		81	}
		82	IProblemRequestor ownerProblemRequestor = this.workingCopyOwner.getProblemRequestor(workingCopy);
79	this.resolveBindings \|= problemRequestor != null && problemRequestor.isActive();	83	this.resolveBindings \|= problemRequestor != null && problemRequestor.isActive();
80		84
81	// create the delta builder (this remembers the current content of the cu)	85	// create the delta builder (this remembers the current content of the cu)
Lines 93-114 Link Here
93		97
94	// report problems	98	// report problems
95	if (this.problems != null && (this.forceProblemDetection \|\| !wasConsistent)) {	99	if (this.problems != null && (this.forceProblemDetection \|\| !wasConsistent)) {
96	try {	100	if (problemRequestor != null) {
97	problemRequestor.beginReporting();	101	reportProblems(workingCopy, problemRequestor);
98	for (Iterator iteraror = this.problems.values().iterator(); iteraror.hasNext();) {	102	}
99	CategorizedProblem[] categorizedProblems = (CategorizedProblem[]) iteraror.next();	103	if (ownerProblemRequestor != null && ownerProblemRequestor != problemRequestor) {
100	if (categorizedProblems == null) continue;	104	reportProblems(workingCopy, ownerProblemRequestor);
101	for (int i = 0, length = categorizedProblems.length; i < length; i++) {
102	CategorizedProblem problem = categorizedProblems[i];
103	if (JavaModelManager.VERBOSE){
104	System.out.println("PROBLEM FOUND while reconciling : " + problem.getMessage());//$NON-NLS-1$
105	}
106	if (this.progressMonitor != null && this.progressMonitor.isCanceled()) break;
107	problemRequestor.acceptProblem(problem);
108	}
109	}
110	} finally {
111	problemRequestor.endReporting();
112	}	105	}
113	}	106	}
114		107
Lines 122-139 Link Here
122	if (this.progressMonitor != null) this.progressMonitor.done();	115	if (this.progressMonitor != null) this.progressMonitor.done();
123	}	116	}
124	}	117	}
		118
		119	/**
		120	* Report working copy problems to a given requestor.
		121	*
		122	* @param workingCopy
		123	* @param problemRequestor
		124	*/
		125	private void reportProblems(CompilationUnit workingCopy, IProblemRequestor problemRequestor) {
		126	try {
		127	problemRequestor.beginReporting();
		128	for (Iterator iteraror = this.problems.values().iterator(); iteraror.hasNext();) {
		129	CategorizedProblem[] categorizedProblems = (CategorizedProblem[]) iteraror.next();
		130	if (categorizedProblems == null) continue;
		131	for (int i = 0, length = categorizedProblems.length; i < length; i++) {
		132	CategorizedProblem problem = categorizedProblems[i];
		133	if (JavaModelManager.VERBOSE){
		134	System.out.println("PROBLEM FOUND while reconciling : " + problem.getMessage());//$NON-NLS-1$
		135	}
		136	if (this.progressMonitor != null && this.progressMonitor.isCanceled()) break;
		137	problemRequestor.acceptProblem(problem);
		138	}
		139	}
		140	} finally {
		141	problemRequestor.endReporting();
		142	}
		143	}
		144
125	/**	145	/**
126	* Returns the working copy this operation is working on.	146	* Returns the working copy this operation is working on.
127	*/	147	*/
128	protected CompilationUnit getWorkingCopy() {	148	protected CompilationUnit getWorkingCopy() {
129	return (CompilationUnit)getElementToProcess();	149	return (CompilationUnit)getElementToProcess();
130	}	150	}
131	/**	151
132	* @see JavaModelOperation#isReadOnly	152	/* (non-Javadoc)
		153	* @see org.eclipse.jdt.internal.core.JavaModelOperation#isReadOnly()
133	*/	154	*/
134	public boolean isReadOnly() {	155	public boolean isReadOnly() {
135	return true;	156	return true;
136	}	157	}
		158
137	/*	159	/*
138	* Makes the given working copy consistent, computes the delta and computes an AST if needed.	160	* Makes the given working copy consistent, computes the delta and computes an AST if needed.
139	* Returns the AST.	161	* Returns the AST.
Lines 232-237 Link Here
232	});	254	});
233	}	255	}
234	}	256	}
		257
235	protected IJavaModelStatus verify() {	258	protected IJavaModelStatus verify() {
236	IJavaModelStatus status = super.verify();	259	IJavaModelStatus status = super.verify();
237	if (!status.isOK()) {	260	if (!status.isOK()) {
Lines 244-248 Link Here
244	return status;	267	return status;
245	}	268	}
246		269
247
248	}	270	}




/*******************************************************************************
 * Copyright (c) 2000, 2007 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

import org.eclipse.jdt.internal.core.PackageFragment;

/**
 * The owner of an {@link ICompilationUnit} handle in working copy mode. 
 * An owner is used to identify a working copy and to create its buffer.
 * <p>
 * Clients should subclass this class to instantiate a working copy owner that is specific to their need and that


		return BufferManager.getDefaultBufferManager().createBuffer(workingCopy);
	}

	/**
	 * Returns the problem requestor used by a working copy of this working copy owner.
	 * <p>
	 * By default, no problem requestor is configured. Clients can override this 
	 * method to provide a requestor.
	 * </p>
	 * 
	 * @param workingCopy The problem requestor used for the given working copy.
	 * If <code>null</code>, then return the problem requestor used for all working 
	 * copies of the working copy owner.
	 * @return the problem requestor to be used by working copies of this working 
	 * copy owner or <code>null</code> if no problem requestor is configured.
	 * 
	 * @since 3.3
	 */
	public IProblemRequestor getProblemRequestor(ICompilationUnit workingCopy) {
		return null;
	}
	
	/**
	 * Returns a new working copy with the given name using this working copy owner to 

	 * However this Java project has the given classpath that is used when resolving names
	 * in this working copy.
	 * </p><p>
	 * If a DOM AST is created using this working copy, then given classpath will be used
	 *  if bindings need to be resolved and problems will be reported to the given problem requestor
	 * if it is not <code>null</code>.
	 * <p></p>
	 * Options used to create the DOM AST are got from {@link JavaCore#getOptions()}
	 * as it is not possible to set the options on a non-existing Java project.
	 * </p><p>
	 * When the working copy instance is created, an {@link IJavaElementDelta#ADDED added delta} is 
	 * reported on this working copy.

	 * @return a new working copy
	 * @see ICompilationUnit#becomeWorkingCopy(IProblemRequestor, IProgressMonitor)
	 * @since 3.2
	 * 
	 * @deprecated Use {@link #newWorkingCopy(String, IClasspathEntry[], IProgressMonitor)} instead.
	 */
	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
		ExternalJavaProject project = new ExternalJavaProject(classpath);

		result.becomeWorkingCopy(problemRequestor, monitor);
		return result;
	}
	
	/**
	 * Returns a new working copy with the given name using this working copy owner to 
	 * create its buffer. 
	 * <p>
	 * This working copy always belongs to the default package in a package
	 * fragment root that corresponds to its Java project, and this Java project never exists.
	 * However this Java project has the given classpath that is used when resolving names
	 * in this working copy.
	 * </p><p>
	 * If a DOM AST is created using this working copy, then given classpath will be used
	 *  if bindings need to be resolved and problems will be reported to the current working copy
	 * owner problem requestor if it is not <code>null</code>.
	 * <p></p>
	 * Options used to create the DOM AST are got from {@link JavaCore#getOptions()}
	 * as it is not possible to set the options on a non-existing Java project.
	 * </p><p>
	 * When the working copy instance is created, an {@link IJavaElementDelta#ADDED added delta} is 
	 * reported on this working copy.
	 * </p><p>
	 * Once done with the working copy, users of this method must discard it using 
	 * {@link ICompilationUnit#discardWorkingCopy()}.
	 * </p><p>
	 * Note that when such working copy is committed, only its buffer is saved (see 
	 * {@link IBuffer#save(IProgressMonitor, boolean)}) but no resource is created.
	 * </p><p>
	 * This method is not intended to be overriden by clients.
	 * </p>
	 * 
	 * @param name the name of the working copy (e.g. "X.java")
	 * @param classpath the classpath used to resolve names in this working copy
	 * @param monitor a progress monitor used to report progress while opening the working copy
	 * 	or <code>null</code> if no progress should be reported 
	 * @throws JavaModelException if the contents of this working copy can
	 *   not be determined. 
	 * @return a new working copy
	 * @see ICompilationUnit#becomeWorkingCopy(IProgressMonitor)
	 * 
	 * @since 3.3
	 */
	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProgressMonitor monitor) throws JavaModelException {
		ExternalJavaProject project = new ExternalJavaProject(classpath);
		IPackageFragment parent = project.getPackageFragmentRoot(Path.EMPTY).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
		result.becomeWorkingCopy(getProblemRequestor(result), monitor);
		return result;
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2007 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

 */
void becomeWorkingCopy(IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException;
/**
 * Changes this compilation unit handle into a working copy. A new {@link IBuffer} is
 * created using this compilation unit handle's owner. Uses the primary owner is none was
 * specified when this compilation unit handle was created.
 * <p>
 * When switching to working copy mode, problems are reported to the {@link IProblemRequestor
 * problem requestor} of the {@link WorkingCopyOwner working copy owner}.
 * </p>
 * <p>
 * Once in working copy mode, changes to this compilation unit or its children are done in memory.
 * Only the new buffer is affected. Using {@link #commitWorkingCopy(boolean, IProgressMonitor)}
 * will bring the underlying resource in sync with this compilation unit.
 * </p>
 * <p>
 * If this compilation unit was already in working copy mode, an internal counter is incremented and no
 * other action is taken on this compilation unit. To bring this compilation unit back into the original mode 
 * (where it reflects the underlying resource), {@link #discardWorkingCopy} must be call as many 
 * times as {@link #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)}.
 * </p>
 * 
 * @param monitor a progress monitor used to report progress while opening this compilation unit
 * 	or <code>null</code> if no progress should be reported 
 * @throws JavaModelException if this compilation unit could not become a working copy.
 * @see #discardWorkingCopy()
 * @since 3.3
 */
void becomeWorkingCopy(IProgressMonitor monitor) throws JavaModelException;
/**
 * Commits the contents of this working copy to its underlying resource.
 *
 * <p>It is possible that the contents of the original resource have changed

 * This has no effect if this compilation unit was not in working copy mode.
 * </p>
 * <p>
 * If <code>becomeWorkingCopy(...)</code> methods was called several times on this
 * compilation unit, {@link #discardWorkingCopy} must be called as 
 * many times before it switches back to the original mode.
 * </p>
 * <p>{@link #discardWorkingCopy()} also has to be called on each compilation unit returned by
 * {@link #getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)}.
 * </p>
 * 
 * @throws JavaModelException if this working copy could not return in its original mode.
 * @see #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)




/*******************************************************************************
 * Copyright (c) 2000, 2007 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

 * changed, and any children that have changed.
 * <p>
 * Deltas have a different status depending on the kind of change they represent.  
 * The list below summarizes each status (as returned by {@link #getKind})
 * and its meaning (see individual constants for a more detailled description):
 * <ul>
 * <li>{@link #ADDED} - The element described by the delta has been added.</li>
 * <li>{@link #REMOVED} - The element described by the delta has been removed.</li>
 * <li>{@link #CHANGED} - The element described by the delta has been changed in some way.  
 * Specification of the type of change is provided by {@link #getFlags} which returns the following values:
 * <ul>
 * <li>{@link #F_ADDED_TO_CLASSPATH} - A classpath entry corresponding to the element
 * has been added to the project's classpath. This flag is only valid if the element is an 
 * {@link IPackageFragmentRoot}.</li>
 * <li>{@link #F_ARCHIVE_CONTENT_CHANGED} - The contents of an archive
 * has changed in some way. This flag is only valid if the element is an {@link IPackageFragmentRoot}
 * which is an archive.</li>
 * <li>{@link #F_CHILDREN} - A child of the element has changed in some way.  This flag
 * is only valid if the element is an {@link IParent}.</li>
 * <li>{@link #F_CLASSPATH_REORDER} - A classpath entry corresponding to the element
 * has changed position in the project's classpath. This flag is only valid if the element is an 
 * {@link IPackageFragmentRoot}.</li>
 * <li>{@link #F_CLOSED} - The underlying {@link org.eclipse.core.resources.IProject}
 * has been closed. This flag is only valid if the element is an {@link IJavaProject}.</li>
 * <li>{@link #F_CONTENT} - The contents of the element have been altered.  This flag
 * is only valid for elements which correspond to files.</li>
 *<li>{@link #F_FINE_GRAINED} - The delta is a fine-grained delta, that is, an analysis down
 * to the members level was done to determine if there were structural changes to members of the element.</li>
 * <li>{@link #F_MODIFIERS} - The modifiers on the element have changed in some way. 
 * This flag is only valid if the element is an {@link IMember}.</li>
 * <li>{@link #F_OPENED} - The underlying {@link org.eclipse.core.resources.IProject}
 * has been opened. This flag is only valid if the element is an {@link IJavaProject}.</li>
 * <li>{@link #F_REMOVED_FROM_CLASSPATH} - A classpath entry corresponding to the element 
 * has been removed from the project's classpath. This flag is only valid if the element is an 
 * {@link IPackageFragmentRoot}.</li>
 * <li>{@link #F_SOURCEATTACHED} - The source attachment path or the source attachment root path
 * of a classpath entry corresponding to the element was added. This flag is only valid if the element is an 
 * {@link IPackageFragmentRoot}.</li>
 * <li>{@link #F_SOURCEDETACHED} - The source attachment path or the source attachment root path
 * of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an 
 * {@link IPackageFragmentRoot}.</li>
 * <li>{@link #F_SUPER_TYPES} - One of the supertypes of an {@link IType} has changed</li>.
 * </ul>
 * </li>
 * </ul>

 * <p>
 * Move operations are indicated by other change flags, layered on top
 * of the change flags described above. If element A is moved to become B,
 * the delta for the  change in A will have status {@link #REMOVED},
 * with change flag {@link #F_MOVED_TO}. In this case,
 * {@link #getMovedToElement} on delta A will return the handle for B.
 * The  delta for B will have status {@link #ADDED}, with change flag
 * {@link #F_MOVED_FROM}, and {@link #getMovedFromElement} on delta
 * B will return the handle for A. (Note, the handle to A in this case represents
 * an element that no longer exists).
 * </p>

 * do not imply anything about the parent or children of the element.
 * </p>
 * <p>
 * The {@link #F_ADDED_TO_CLASSPATH}, {@link #F_REMOVED_FROM_CLASSPATH} and
 * {@link #F_CLASSPATH_REORDER} flags are triggered by changes to a project's classpath. They do not mean that
 * the underlying resource was added, removed or changed. For example, if a project P already contains a folder src, then 
 * adding a classpath entry with the 'P/src' path to the project's classpath will result in an {@link IJavaElementDelta} 
 * with the {@link #F_ADDED_TO_CLASSPATH} flag for the {@link IPackageFragmentRoot} P/src.
 * On the contrary, if a resource is physically added, removed or changed and this resource corresponds to a classpath
 * entry of the project, then an {@link IJavaElementDelta} with the {@link #ADDED}, 
 * {@link #REMOVED}, or {@link #CHANGED} kind will be fired.
 * </p>
 * <p>
 * Note that when a source attachment path or a source attachment root path is changed, then the flags of the delta contain
 * both {@link #F_SOURCEATTACHED} and {@link #F_SOURCEDETACHED}.
 * </p>
 * <p>
 * No assumptions should be made on whether the java element delta tree is rooted at the {@link IJavaModel}
 * level or not.
 * </p>
 * <p>
 * {@link IJavaElementDelta} object are not valid outside the dynamic scope
 * of the notification.
 * </p>
 * <p>


	/**
	 * Change flag indicating that the modifiers of the element have changed.
	 * This flag is only valid if the element is an {@link IMember}. 
	 */
	public int F_MODIFIERS = 0x000002;

	/**
	 * Change flag indicating that there are changes to the children of the element.
	 * This flag is only valid if the element is an {@link IParent}. 
	 */
	public int F_CHILDREN = 0x000008;

	/**
	 * Change flag indicating that the element was moved from another location.
	 * The location of the old element can be retrieved using {@link #getMovedFromElement}.
	 */
	public int F_MOVED_FROM = 0x000010;

	/**
	 * Change flag indicating that the element was moved to another location.
	 * The location of the new element can be retrieved using {@link #getMovedToElement}.
	 */
	public int F_MOVED_TO = 0x000020;

	/**
	 * Change flag indicating that a classpath entry corresponding to the element has been added to the project's classpath. 
	 * This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	 */
	public int F_ADDED_TO_CLASSPATH = 0x000040;

	/**
	 * Change flag indicating that a classpath entry corresponding to the element has been removed from the project's 
	 * classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	 */
	public int F_REMOVED_FROM_CLASSPATH = 0x000080;

	/**
	 * Change flag indicating that a classpath entry corresponding to the element has changed position in the project's 
	 * classpath. This flag is only valid if the element is an {@link IPackageFragmentRoot}.
	 * @deprecated Use {@link #F_REORDER} instead.
	 */
	public int F_CLASSPATH_REORDER = 0x000100;
	/**
	 * Change flag indicating that the element has changed position relatively to its siblings. 
	 * If the element is an {@link IPackageFragmentRoot},  a classpath entry corresponding 
	 * to the element has changed position in the project's classpath.
	 * 
	 * @since 2.1

	public int F_REORDER = 0x000100;

	/**
	 * Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
	 * opened. This flag is only valid if the element is an {@link IJavaProject}. 
	 */
	public int F_OPENED = 0x000200;

	/**
	 * Change flag indicating that the underlying {@link org.eclipse.core.resources.IProject} has been
	 * closed. This flag is only valid if the element is an {@link IJavaProject}. 
	 */
	public int F_CLOSED = 0x000400;

	/**
	 * Change flag indicating that one of the supertypes of an {@link IType}
	 * has changed.
	 */
	public int F_SUPER_TYPES = 0x000800;

	/**
	 * Change flag indicating that the source attachment path or the source attachment root path of a classpath entry 
	 * corresponding to the element was added. This flag is only valid if the element is an 
	 * {@link IPackageFragmentRoot}.
	 */
	public int F_SOURCEATTACHED = 0x001000;	

	/**
	 * Change flag indicating that the source attachment path or the source attachment root path of a classpath entry 
	 * corresponding to the element was removed. This flag is only valid if the element is an 
	 * {@link IPackageFragmentRoot}.
	 */
	public int F_SOURCEDETACHED = 0x002000;	
	

	 * members.
	 * <p>
	 * Clients can use this flag to find out if a compilation unit 
     * that have a {@link #F_CONTENT} change should assume that there are 
     * no finer grained changes ({@link #F_FINE_GRAINED} is set) or if 
     * finer grained changes were not considered ({@link #F_FINE_GRAINED} 
     * is not set). 
     * 
     * @since 2.0


	/**
	 * Change flag indicating that the element's archive content on the classpath has changed.
	 * This flag is only valid if the element is an {@link IPackageFragmentRoot}
	 * which is an archive.
	 * 
	 * @see IPackageFragmentRoot#isArchive()

	/**
	 * Change flag indicating that a compilation unit has become a primary working copy, or that a 
	 * primary working copy has reverted to a compilation unit.
	 * This flag is only valid if the element is an {@link ICompilationUnit}.
	 * 
	 * @since 3.0
	 */


	/**
	 * Change flag indicating that the raw classpath (or the output folder) of a project has changed. 
	 * This flag is only valid if the element is an {@link IJavaProject}.
	 *
	 * @since 3.0
	 */


	/**
	 * Change flag indicating that the resource of a primary compilation unit has changed.
	 * This flag is only valid if the element is a primary {@link ICompilationUnit}.
	 * 
	 * @since 3.0
	 */

	/**
	 * Change flag indicating that a reconcile operation has affected the compilation unit AST created in a 
	 * previous reconcile operation. Use {@link #getCompilationUnitAST()} to retrieve the AST (if any is available).
	 * This flag is only valid if the element is an {@link ICompilationUnit} in working copy mode.
	 * 
	 * @since 3.2
	 */

	
	/**
	 * Change flag indicating that the categories of the element have changed.
	 * This flag is only valid if the element is an {@link IMember}. 
	 * 
	 * @since 3.2
	 */

	 * This returns a non-null value if and only if:
	 * <ul>
	 * <li>the last reconcile operation on this working copy requested an AST</li>
	 * <li>this delta's element is an {@link ICompilationUnit} in working copy mode</li>
	 * <li>the delta comes from a {@link ElementChangedEvent#POST_RECONCILE} event
	 * </ul>
	 * 
	 * @return the AST created during the last reconcile operation
	 * @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, org.eclipse.core.runtime.IProgressMonitor)
	 * @see #F_AST_AFFECTED

	public int getFlags();

	/**
	 * Returns the kind of this delta - one of {@link #ADDED}, {@link #REMOVED},
	 * or {@link #CHANGED}.
	 * 
	 * @return the kind of this delta
	 */

	/**
	 * Returns an element describing this element before it was moved
	 * to its current location, or <code>null</code> if the
	 * {@link #F_MOVED_FROM} change flag is not set. 
	 * 
	 * @return an element describing this element before it was moved
	 * to its current location, or <code>null</code> if the
	 * {@link #F_MOVED_FROM} change flag is not set
	 */
	public IJavaElement getMovedFromElement();

	/**
	 * Returns an element describing this element in its new location,
	 * or <code>null</code> if the {@link #F_MOVED_TO} change
	 * flag is not set.
	 * 
	 * @return an element describing this element in its new location,
	 * or <code>null</code> if the {@link #F_MOVED_TO} change
	 * flag is not set
	 */
	public IJavaElement getMovedToElement();




	public static Test suite() {
		return buildModelTestSuite(WorkingCopyOwnerTests.class);
	}

	// Use this static initializer to specify subset for tests
	// All specified tests which do not belong to the class are skipped...
	static {
		// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
//		TESTS_NAMES = new String[] { "testNewWorkingCopy03" };
		// Numbers of tests to run: "test<number>" will be run for each number of this array
//		TESTS_NUMBERS = new int[] { 2, 12 };
		// Range numbers of tests to run: all tests between "test<first>" and "test<last>" will be run for { first, last }
//		TESTS_RANGE = new int[] { 16, -1 };
	}


				return buffer;
			}
		};
//		this.workingCopy = owner.newWorkingCopy("X.java", null/*no classpath*/, null/*no problem requestor*/, null/*no progress monitor*/);
		this.workingCopy = owner.newWorkingCopy("X.java", null/*no classpath*/, null/*no progress monitor*/);
		this.workingCopy.commitWorkingCopy(true, null);
		assertFalse("Should not have unsaved changes", this.workingCopy.hasUnsavedChanges());
	}




	}	
	public ICompilationUnit getWorkingCopy(String path, String source) throws JavaModelException {
		return getWorkingCopy(path, source, false);
	}
	public ICompilationUnit getWorkingCopy(String path, String source, boolean computeProblems) throws JavaModelException {
		if (this.wcOwner == null) this.wcOwner = new WorkingCopyOwner() {};
		return getWorkingCopy(path, source, this.wcOwner, computeProblems);

	protected ICompilationUnit newExternalWorkingCopy(String name, final String contents) throws JavaModelException {
		return newExternalWorkingCopy(name, null/*no classpath*/, null/*no problem requestor*/, contents);
	}
	protected ICompilationUnit newExternalWorkingCopy(String name, IClasspathEntry[] classpath, final IProblemRequestor problemRequestor, final String contents) throws JavaModelException {
		WorkingCopyOwner owner = new WorkingCopyOwner() {
			public IBuffer createBuffer(ICompilationUnit wc) {
				IBuffer buffer = super.createBuffer(wc);
				buffer.setContents(contents);
				return buffer;
			}

			public IProblemRequestor getProblemRequestor(ICompilationUnit workingCopy) {
				return problemRequestor;
			}
			
		};
//		return owner.newWorkingCopy(name, classpath, problemRequestor, null/*no progress monitor*/);
		return owner.newWorkingCopy(name, classpath, null/*no progress monitor*/);
	}

	public byte[] read(java.io.File file) throws java.io.IOException {

Return to bug 175243

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/WorkingCopyOwner.java (-6 / +75 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 19-25 Link Here
19	import org.eclipse.jdt.internal.core.PackageFragment;	19	import org.eclipse.jdt.internal.core.PackageFragment;
20		20
21	/**	21	/**
22	* The owner of an <code>ICompilationUnit</code> handle in working copy mode.	22	* The owner of an {@link ICompilationUnit} handle in working copy mode.
23	* An owner is used to identify a working copy and to create its buffer.	23	* An owner is used to identify a working copy and to create its buffer.
24	* <p>	24	* <p>
25	* Clients should subclass this class to instantiate a working copy owner that is specific to their need and that	25	* Clients should subclass this class to instantiate a working copy owner that is specific to their need and that
Lines 71-76 Link Here
71		71
72	return BufferManager.getDefaultBufferManager().createBuffer(workingCopy);	72	return BufferManager.getDefaultBufferManager().createBuffer(workingCopy);
73	}	73	}
		74
		75	/**
		76	* Returns the problem requestor used by a working copy of this working copy owner.
		77	* <p>
		78	* By default, no problem requestor is configured. Clients can override this
		79	* method to provide a requestor.
		80	* </p>
		81	*
		82	* @param workingCopy The problem requestor used for the given working copy.
		83	* If <code>null</code>, then return the problem requestor used for all working
		84	* copies of the working copy owner.
		85	* @return the problem requestor to be used by working copies of this working
		86	* copy owner or <code>null</code> if no problem requestor is configured.
		87	*
		88	* @since 3.3
		89	*/
		90	public IProblemRequestor getProblemRequestor(ICompilationUnit workingCopy) {
		91	return null;
		92	}
74		93
75	/**	94	/**
76	* Returns a new working copy with the given name using this working copy owner to	95	* Returns a new working copy with the given name using this working copy owner to
Lines 81-91 Link Here
81	* However this Java project has the given classpath that is used when resolving names	100	* However this Java project has the given classpath that is used when resolving names
82	* in this working copy.	101	* in this working copy.
83	* </p><p>	102	* </p><p>
84	* A DOM AST created using this working copy will have bindings resolved using the given	103	* If a DOM AST is created using this working copy, then given classpath will be used
85	* classpath, and problem are reported to the given problem requestor.	104	* if bindings need to be resolved and problems will be reported to the given problem requestor
		105	* if it is not <code>null</code>.
86	* <p></p>	106	* <p></p>
87	* <code>JavaCore#getOptions()</code> is used to create the DOM AST as it is not	107	* Options used to create the DOM AST are got from {@link JavaCore#getOptions()}
88	* possible to set the options on the non-existing Java project.	108	* as it is not possible to set the options on a non-existing Java project.
89	* </p><p>	109	* </p><p>
90	* When the working copy instance is created, an {@link IJavaElementDelta#ADDED added delta} is	110	* When the working copy instance is created, an {@link IJavaElementDelta#ADDED added delta} is
91	* reported on this working copy.	111	* reported on this working copy.
Lines 111-116 Link Here
111	* @return a new working copy	131	* @return a new working copy
112	* @see ICompilationUnit#becomeWorkingCopy(IProblemRequestor, IProgressMonitor)	132	* @see ICompilationUnit#becomeWorkingCopy(IProblemRequestor, IProgressMonitor)
113	* @since 3.2	133	* @since 3.2
		134	*
		135	* @deprecated Use {@link #newWorkingCopy(String, IClasspathEntry[], IProgressMonitor)} instead.
114	*/	136	*/
115	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {	137	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
116	ExternalJavaProject project = new ExternalJavaProject(classpath);	138	ExternalJavaProject project = new ExternalJavaProject(classpath);
Lines 119-123 Link Here
119	result.becomeWorkingCopy(problemRequestor, monitor);	141	result.becomeWorkingCopy(problemRequestor, monitor);
120	return result;	142	return result;
121	}	143	}
		144
		145	/**
		146	* Returns a new working copy with the given name using this working copy owner to
		147	* create its buffer.
		148	* <p>
		149	* This working copy always belongs to the default package in a package
		150	* fragment root that corresponds to its Java project, and this Java project never exists.
		151	* However this Java project has the given classpath that is used when resolving names
		152	* in this working copy.
		153	* </p><p>
		154	* If a DOM AST is created using this working copy, then given classpath will be used
		155	* if bindings need to be resolved and problems will be reported to the current working copy
		156	* owner problem requestor if it is not <code>null</code>.
		157	* <p></p>
		158	* Options used to create the DOM AST are got from {@link JavaCore#getOptions()}
		159	* as it is not possible to set the options on a non-existing Java project.
		160	* </p><p>
		161	* When the working copy instance is created, an {@link IJavaElementDelta#ADDED added delta} is
		162	* reported on this working copy.
		163	* </p><p>
		164	* Once done with the working copy, users of this method must discard it using
		165	* {@link ICompilationUnit#discardWorkingCopy()}.
		166	* </p><p>
		167	* Note that when such working copy is committed, only its buffer is saved (see
		168	* {@link IBuffer#save(IProgressMonitor, boolean)}) but no resource is created.
		169	* </p><p>
		170	* This method is not intended to be overriden by clients.
		171	* </p>
		172	*
		173	* @param name the name of the working copy (e.g. "X.java")
		174	* @param classpath the classpath used to resolve names in this working copy
		175	* @param monitor a progress monitor used to report progress while opening the working copy
		176	* or <code>null</code> if no progress should be reported
		177	* @throws JavaModelException if the contents of this working copy can
		178	* not be determined.
		179	* @return a new working copy
		180	* @see ICompilationUnit#becomeWorkingCopy(IProgressMonitor)
		181	*
		182	* @since 3.3
		183	*/
		184	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProgressMonitor monitor) throws JavaModelException {
		185	ExternalJavaProject project = new ExternalJavaProject(classpath);
		186	IPackageFragment parent = project.getPackageFragmentRoot(Path.EMPTY).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		187	CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
		188	result.becomeWorkingCopy(getProblemRequestor(result), monitor);
		189	return result;
		190	}
122		191
123	}	192	}

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/ICompilationUnit.java (-2 / +32 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 70-75 Link Here
70	*/	70	*/
71	void becomeWorkingCopy(IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException;	71	void becomeWorkingCopy(IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException;
72	/**	72	/**
		73	* Changes this compilation unit handle into a working copy. A new {@link IBuffer} is
		74	* created using this compilation unit handle's owner. Uses the primary owner is none was
		75	* specified when this compilation unit handle was created.
		76	* <p>
		77	* When switching to working copy mode, problems are reported to the {@link IProblemRequestor
		78	* problem requestor} of the {@link WorkingCopyOwner working copy owner}.
		79	* </p>
		80	* <p>
		81	* Once in working copy mode, changes to this compilation unit or its children are done in memory.
		82	* Only the new buffer is affected. Using {@link #commitWorkingCopy(boolean, IProgressMonitor)}
		83	* will bring the underlying resource in sync with this compilation unit.
		84	* </p>
		85	* <p>
		86	* If this compilation unit was already in working copy mode, an internal counter is incremented and no
		87	* other action is taken on this compilation unit. To bring this compilation unit back into the original mode
		88	* (where it reflects the underlying resource), {@link #discardWorkingCopy} must be call as many
		89	* times as {@link #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)}.
		90	* </p>
		91	*
		92	* @param monitor a progress monitor used to report progress while opening this compilation unit
		93	* or <code>null</code> if no progress should be reported
		94	* @throws JavaModelException if this compilation unit could not become a working copy.
		95	* @see #discardWorkingCopy()
		96	* @since 3.3
		97	*/
		98	void becomeWorkingCopy(IProgressMonitor monitor) throws JavaModelException;
		99	/**
73	* Commits the contents of this working copy to its underlying resource.	100	* Commits the contents of this working copy to its underlying resource.
74	*	101	*
75	* <p>It is possible that the contents of the original resource have changed	102	* <p>It is possible that the contents of the original resource have changed
Lines 223-232 Link Here
223	* This has no effect if this compilation unit was not in working copy mode.	250	* This has no effect if this compilation unit was not in working copy mode.
224	* </p>	251	* </p>
225	* <p>	252	* <p>
226	* If {@link #becomeWorkingCopy} was called several times on this	253	* If <code>becomeWorkingCopy(...)</code> methods was called several times on this
227	* compilation unit, {@link #discardWorkingCopy} must be called as	254	* compilation unit, {@link #discardWorkingCopy} must be called as
228	* many times before it switches back to the original mode.	255	* many times before it switches back to the original mode.
229	* </p>	256	* </p>
		257	* <p>{@link #discardWorkingCopy()} also has to be called on each compilation unit returned by
		258	* {@link #getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)}.
		259	* </p>
230	*	260	*
231	* @throws JavaModelException if this working copy could not return in its original mode.	261	* @throws JavaModelException if this working copy could not return in its original mode.
232	* @see #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)	262	* @see #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)

Lines 41-54 Link Here

(-)src/org/eclipse/jdt/core/tests/model/WorkingCopyOwnerTests.java (-4 / +3 lines)
41	public static Test suite() {	41	public static Test suite() {
42	return buildModelTestSuite(WorkingCopyOwnerTests.class);	42	return buildModelTestSuite(WorkingCopyOwnerTests.class);
43	}	43	}
		44
44	// Use this static initializer to specify subset for tests	45	// Use this static initializer to specify subset for tests
45	// All specified tests which do not belong to the class are skipped...	46	// All specified tests which do not belong to the class are skipped...
46	static {	47	static {
47	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
48	// TESTS_NAMES = new String[] { "testNewWorkingCopy03" };	48	// TESTS_NAMES = new String[] { "testNewWorkingCopy03" };
49	// Numbers of tests to run: "test<number>" will be run for each number of this array
50	// TESTS_NUMBERS = new int[] { 2, 12 };	49	// TESTS_NUMBERS = new int[] { 2, 12 };
51	// Range numbers of tests to run: all tests between "test<first>" and "test<last>" will be run for { first, last }
52	// TESTS_RANGE = new int[] { 16, -1 };	50	// TESTS_RANGE = new int[] { 16, -1 };
53	}	51	}
54		52
Lines 1031-1037 Link Here
1031	return buffer;	1029	return buffer;
1032	}	1030	}
1033	};	1031	};
1034	this.workingCopy = owner.newWorkingCopy("X.java", null/no classpath/, null/no problem requestor/, null/no progress monitor/);	1032	// this.workingCopy = owner.newWorkingCopy("X.java", null/no classpath/, null/no problem requestor/, null/no progress monitor/);
		1033	this.workingCopy = owner.newWorkingCopy("X.java", null/no classpath/, null/no progress monitor/);
1035	this.workingCopy.commitWorkingCopy(true, null);	1034	this.workingCopy.commitWorkingCopy(true, null);
1036	assertFalse("Should not have unsaved changes", this.workingCopy.hasUnsavedChanges());	1035	assertFalse("Should not have unsaved changes", this.workingCopy.hasUnsavedChanges());
1037	}	1036	}

Lines 1538-1544 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (-3 / +9 lines)
1538	}	1538	}
1539	public ICompilationUnit getWorkingCopy(String path, String source) throws JavaModelException {	1539	public ICompilationUnit getWorkingCopy(String path, String source) throws JavaModelException {
1540	return getWorkingCopy(path, source, false);	1540	return getWorkingCopy(path, source, false);
1541	}	1541	}
1542	public ICompilationUnit getWorkingCopy(String path, String source, boolean computeProblems) throws JavaModelException {	1542	public ICompilationUnit getWorkingCopy(String path, String source, boolean computeProblems) throws JavaModelException {
1543	if (this.wcOwner == null) this.wcOwner = new WorkingCopyOwner() {};	1543	if (this.wcOwner == null) this.wcOwner = new WorkingCopyOwner() {};
1544	return getWorkingCopy(path, source, this.wcOwner, computeProblems);	1544	return getWorkingCopy(path, source, this.wcOwner, computeProblems);
Lines 1632-1646 Link Here
1632	protected ICompilationUnit newExternalWorkingCopy(String name, final String contents) throws JavaModelException {	1632	protected ICompilationUnit newExternalWorkingCopy(String name, final String contents) throws JavaModelException {
1633	return newExternalWorkingCopy(name, null/no classpath/, null/no problem requestor/, contents);	1633	return newExternalWorkingCopy(name, null/no classpath/, null/no problem requestor/, contents);
1634	}	1634	}
1635	protected ICompilationUnit newExternalWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, final String contents) throws JavaModelException {	1635	protected ICompilationUnit newExternalWorkingCopy(String name, IClasspathEntry[] classpath, final IProblemRequestor problemRequestor, final String contents) throws JavaModelException {
1636	WorkingCopyOwner owner = new WorkingCopyOwner() {	1636	WorkingCopyOwner owner = new WorkingCopyOwner() {
1637	public IBuffer createBuffer(ICompilationUnit wc) {	1637	public IBuffer createBuffer(ICompilationUnit wc) {
1638	IBuffer buffer = super.createBuffer(wc);	1638	IBuffer buffer = super.createBuffer(wc);
1639	buffer.setContents(contents);	1639	buffer.setContents(contents);
1640	return buffer;	1640	return buffer;
1641	}	1641	}
		1642
		1643	public IProblemRequestor getProblemRequestor(ICompilationUnit workingCopy) {
		1644	return problemRequestor;
		1645	}
		1646
1642	};	1647	};
1643	return owner.newWorkingCopy(name, classpath, problemRequestor, null/no progress monitor/);	1648	// return owner.newWorkingCopy(name, classpath, problemRequestor, null/no progress monitor/);
		1649	return owner.newWorkingCopy(name, classpath, null/no progress monitor/);
1644	}	1650	}
1645		1651
1646	public byte[] read(java.io.File file) throws java.io.IOException {	1652	public byte[] read(java.io.File file) throws java.io.IOException {