org.eclipse.jdt/org.eclipse.jdt.core/3.20.0 : org/eclipse/jdt/core/ICompilationUnit.java

ICompilationUnit

http://www.eclipse.org/jdt: Java Development Tools Core (Eclipse Foundation)

Eclipse Public License - v 2.0

Copyright (c) 2000, 2019 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
    IBM Corporation - added J2SE 1.5 support
/*******************************************************************************
 * Copyright (c) 2000, 2019 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     IBM Corporation - added J2SE 1.5 support
 *******************************************************************************/
package org.eclipse.jdt.core;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.text.edits.UndoEdit;


Represents an entire Java compilation unit (source file with one of the Java-like extensions). Compilation unit elements need to be opened before they can be navigated or manipulated. The children are of type IPackageDeclaration, IImportContainer, and IType, and appear in the order in which they are declared in the source. If a source file cannot be parsed, its structure remains unknown. Use IJavaElement.isStructureKnown to determine whether this is the case. 
@noimplement This interface is not intended to be implemented by clients./**
 * Represents an entire Java compilation unit (source file with one of the
 * {@link JavaCore#getJavaLikeExtensions() Java-like extensions}).
 * Compilation unit elements need to be opened before they can be navigated or manipulated.
 * The children are of type {@link IPackageDeclaration},
 * {@link IImportContainer}, and {@link IType},
 * and appear in the order in which they are declared in the source.
 * If a source file cannot be parsed, its structure remains unknown.
 * Use {@link IJavaElement#isStructureKnown} to determine whether this is
 * the case.
 *
 * @noimplement This interface is not intended to be implemented by clients.
 */
@SuppressWarnings("deprecation")
public interface ICompilationUnit extends ITypeRoot, IWorkingCopy, ISourceManipulation {
Constant indicating that a reconcile operation should not return an AST.
Since: 3.0/**
 * Constant indicating that a reconcile operation should not return an AST.
 * @since 3.0
 */
public static final int NO_AST = 0;

Constant indicating that a reconcile operation should recompute the problems
even if the source hasn't changed.
Since: 3.3/**
 * Constant indicating that a reconcile operation should recompute the problems
 * even if the source hasn't changed.
 * @since 3.3
 */
public static final int FORCE_PROBLEM_DETECTION = 0x01;

Constant indicating that a reconcile operation should enable the statements recovery.
See Also: setStatementsRecovery.setStatementsRecovery(boolean)
Since: 3.3/**
 * Constant indicating that a reconcile operation should enable the statements recovery.
 * @see ASTParser#setStatementsRecovery(boolean)
 * @since 3.3
 */
public static final int ENABLE_STATEMENTS_RECOVERY = 0x02;

Constant indicating that a reconcile operation should enable the bindings recovery
See Also: setBindingsRecovery.setBindingsRecovery(boolean)
IBinding.isRecovered()
Since: 3.3/**
 * Constant indicating that a reconcile operation should enable the bindings recovery
 * @see ASTParser#setBindingsRecovery(boolean)
 * @see IBinding#isRecovered()
 * @since 3.3
 */
public static final int ENABLE_BINDINGS_RECOVERY = 0x04;

Constant indicating that a reconcile operation could ignore to parse the method bodies.
See Also: setIgnoreMethodBodies.setIgnoreMethodBodies(boolean)
Since: 3.5.2/**
 * Constant indicating that a reconcile operation could ignore to parse the method bodies.
 * @see ASTParser#setIgnoreMethodBodies(boolean)
 * @since 3.5.2
 */
public static final int IGNORE_METHOD_BODIES = 0x08;


Applies a text edit to the compilation unit's buffer.
 Note that the edit is simply applied to the compilation unit's buffer. In particular the undo edit is not grouped with previous undo edits if the buffer doesn't implement ITextEditCapability. If it does, the exact semantics for grouping undo edit depends on how ITextEditCapability.applyTextEdit(TextEdit, IProgressMonitor) is implemented. 
Params: edit – the edit to apply
monitor – the progress monitor to use or null if no progress should be reported
Throws: JavaModelException – if this edit can not be applied to the compilation unit's buffer. Reasons include:

This compilation unit does not exist (IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST).
The provided edit can not be applied as there is a problem with the text edit locations (IJavaModelStatusConstants.BAD_TEXT_EDIT_LOCATION).
Returns: the undo edit
Since: 3.4/**
 * Applies a text edit to the compilation unit's buffer.
 * <p>
 * Note that the edit is simply applied to the compilation unit's buffer.
 * In particular the undo edit is not grouped with previous undo edits
 * if the buffer doesn't implement {@link IBuffer.ITextEditCapability}.
 * If it does, the exact semantics for grouping undo edit depends
 * on how {@link IBuffer.ITextEditCapability#applyTextEdit(TextEdit, IProgressMonitor)}
 * is implemented.
 * </p>
 *
 * @param edit the edit to apply
 * @param monitor the progress monitor to use or <code>null</code> if no progress should be reported
 * @return the undo edit
 * @throws JavaModelException if this edit can not be applied to the compilation unit's buffer. Reasons include:
 * <ul>
 * <li>This compilation unit does not exist ({@link IJavaModelStatusConstants#ELEMENT_DOES_NOT_EXIST}).</li>
 * <li>The provided edit can not be applied as there is a problem with the text edit locations ({@link IJavaModelStatusConstants#BAD_TEXT_EDIT_LOCATION}).</li>
 * </ul>
 *
 * @since 3.4
 */
public UndoEdit applyTextEdit(TextEdit edit, IProgressMonitor monitor) throws JavaModelException;

Changes this compilation unit handle into a working copy. A new IBuffer is created using this compilation unit handle's owner. Uses the primary owner if none was specified when this compilation unit handle was created.  When switching to working copy mode, problems are reported to given IProblemRequestor. Note that once in working copy mode, the given IProblemRequestor is ignored. Only the original IProblemRequestor is used to report subsequent problems. 
 Once in working copy mode, changes to this compilation unit or its children are done in memory. Only the new buffer is affected. Using commitWorkingCopy(boolean, IProgressMonitor) will bring the underlying resource in sync with this compilation unit. 
 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), discardWorkingCopy must be call as many times as becomeWorkingCopy(IProblemRequestor, IProgressMonitor). 
Params: problemRequestor – a requestor which will get notified of problems detected during
	reconciling as they are discovered. The requestor can be set to null indicating
	that the client is not interested in problems.
monitor – a progress monitor used to report progress while opening this compilation unit
	or null if no progress should be reported
Throws: JavaModelException – if this compilation unit could not become a working copy.
See Also: discardWorkingCopy()
Since: 3.0
Deprecated: Use becomeWorkingCopy(IProgressMonitor) instead. Note that if this deprecated method is used, problems will be reported to the given problem requestor as well as the problem requestor returned by the working copy owner (if not null)./**
 * 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 if none was
 * specified when this compilation unit handle was created.
 * <p>
 * When switching to working copy mode, problems are reported to given
 * {@link IProblemRequestor}. Note that once in working copy mode, the given
 * {@link IProblemRequestor} is ignored. Only the original {@link IProblemRequestor}
 * is used to report subsequent problems.
 * </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 problemRequestor a requestor which will get notified of problems detected during
 * 	reconciling as they are discovered. The requestor can be set to <code>null</code> indicating
 * 	that the client is not interested in problems.
 * @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.0
 *
 * @deprecated Use {@link #becomeWorkingCopy(IProgressMonitor)} instead.
 * 	Note that if this deprecated method is used, problems will be reported to the given problem requestor
 * 	as well as the problem requestor returned by the working copy owner (if not null).
 */
void becomeWorkingCopy(IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException;
Changes this compilation unit handle into a working copy. A new IBuffer is created using this compilation unit handle's owner. Uses the primary owner if none was specified when this compilation unit handle was created.  When switching to working copy mode, problems are reported to the 
problem requestor of the working copy owner. 
 Once in working copy mode, changes to this compilation unit or its children are done in memory. Only the new buffer is affected. Using commitWorkingCopy(boolean, IProgressMonitor) will bring the underlying resource in sync with this compilation unit. 
 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), discardWorkingCopy must be call as many times as becomeWorkingCopy(IProblemRequestor, IProgressMonitor). 
Params: monitor – a progress monitor used to report progress while opening this compilation unit
	or null if no progress should be reported
Throws: JavaModelException – if this compilation unit could not become a working copy.
See Also: discardWorkingCopy()
Since: 3.3/**
 * 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 if 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.
It is possible that the contents of the original resource have changed
since this working copy was created, in which case there is an update conflict.
The value of the force parameter affects the resolution of
such a conflict:

 true - in this case the contents of this working copy are applied to
	the underlying resource even though this working copy was created before
	a subsequent change in the resource
 false - in this case a JavaModelException is thrown


Since 2.1, a working copy can be created on a not-yet existing compilation
unit. In particular, such a working copy can then be committed in order to create
the corresponding compilation unit.

Params: force – a flag to handle the cases when the contents of the original resource have changed
since this working copy was created
monitor – the given progress monitor
Throws: JavaModelException – if this working copy could not commit. Reasons include:

 A CoreException occurred while updating an underlying resource 
 This element is not a working copy (INVALID_ELEMENT_TYPES)
 A update conflict (described above) (UPDATE_CONFLICT)
Since: 3.0/**
 * Commits the contents of this working copy to its underlying resource.
 *
 * <p>It is possible that the contents of the original resource have changed
 * since this working copy was created, in which case there is an update conflict.
 * The value of the <code>force</code> parameter affects the resolution of
 * such a conflict:<ul>
 * <li> <code>true</code> - in this case the contents of this working copy are applied to
 * 	the underlying resource even though this working copy was created before
 *		a subsequent change in the resource</li>
 * <li> <code>false</code> - in this case a {@link JavaModelException} is thrown</li>
 * </ul>
 * <p>
 * Since 2.1, a working copy can be created on a not-yet existing compilation
 * unit. In particular, such a working copy can then be committed in order to create
 * the corresponding compilation unit.
 * </p>
 * @param force a flag to handle the cases when the contents of the original resource have changed
 * since this working copy was created
 * @param monitor the given progress monitor
 * @throws JavaModelException if this working copy could not commit. Reasons include:
 * <ul>
 * <li> A {@link org.eclipse.core.runtime.CoreException} occurred while updating an underlying resource
 * <li> This element is not a working copy (INVALID_ELEMENT_TYPES)
 * <li> A update conflict (described above) (UPDATE_CONFLICT)
 * </ul>
 * @since 3.0
 */
void commitWorkingCopy(boolean force, IProgressMonitor monitor) throws JavaModelException;
Creates and returns an non-static import declaration in this compilation unit
with the given name. This method is equivalent to
createImport(name, Flags.AccDefault, sibling, monitor).
Params: name – the name of the import declaration to add as defined by JLS2 7.5. (For example: "java.io.File" or
 "java.awt.*")
sibling – the existing element which the import declaration will be inserted immediately before (if
 null , then this import will be inserted as the last import declaration.
monitor – the progress monitor to notify
Throws: JavaModelException – if the element could not be created. Reasons include:

 This Java element does not exist or the specified sibling does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource 
 The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 The name is not a valid import name (INVALID_NAME)
See Also: createImport(String, IJavaElement, int, IProgressMonitor)
Returns: the newly inserted import declaration (or the previously existing one in case attempting to create a duplicate)/**
 * Creates and returns an non-static import declaration in this compilation unit
 * with the given name. This method is equivalent to
 * <code>createImport(name, Flags.AccDefault, sibling, monitor)</code>.
 *
 * @param name the name of the import declaration to add as defined by JLS2 7.5. (For example: <code>"java.io.File"</code> or
 *  <code>"java.awt.*"</code>)
 * @param sibling the existing element which the import declaration will be inserted immediately before (if
 *	<code> null </code>, then this import will be inserted as the last import declaration.
 * @param monitor the progress monitor to notify
 * @return the newly inserted import declaration (or the previously existing one in case attempting to create a duplicate)
 *
 * @throws JavaModelException if the element could not be created. Reasons include:
 * <ul>
 * <li> This Java element does not exist or the specified sibling does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * <li> A {@link org.eclipse.core.runtime.CoreException} occurred while updating an underlying resource
 * <li> The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 * <li> The name is not a valid import name (INVALID_NAME)
 * </ul>
 * @see #createImport(String, IJavaElement, int, IProgressMonitor)
 */
IImportDeclaration createImport(String name, IJavaElement sibling, IProgressMonitor monitor) throws JavaModelException;

Creates and returns an import declaration in this compilation unit
with the given name.

Optionally, the new element can be positioned before the specified
sibling. If no sibling is specified, the element will be inserted
as the last import declaration in this compilation unit.

If the compilation unit already includes the specified import declaration,
the import is not generated (it does not generate duplicates).
Note that it is valid to specify both a single-type import and an on-demand import
for the same package, for example "java.io.File" and
"java.io.*", in which case both are preserved since the semantics
of this are not the same as just importing "java.io.*".
Importing "java.lang.*", or the package in which the compilation unit
is defined, are not treated as special cases.  If they are specified, they are
included in the result.

Note: This API element is only needed for dealing with Java code that uses
new language features of J2SE 5.0.

Params: name – the name of the import declaration to add as defined by JLS2 7.5. (For example: "java.io.File" or
 "java.awt.*")
sibling – the existing element which the import declaration will be inserted immediately before (if
 null , then this import will be inserted as the last import declaration.
flags – Flags.AccStatic for static imports, or Flags.AccDefault for regular imports; other modifier flags are ignored
monitor – the progress monitor to notify
Throws: JavaModelException – if the element could not be created. Reasons include:

 This Java element does not exist or the specified sibling does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource 
 The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 The name is not a valid import name (INVALID_NAME)
See Also: Flags
Returns: the newly inserted import declaration (or the previously existing one in case attempting to create a duplicate)
Since: 3.0/**
 * Creates and returns an import declaration in this compilation unit
 * with the given name.
 * <p>
 * Optionally, the new element can be positioned before the specified
 * sibling. If no sibling is specified, the element will be inserted
 * as the last import declaration in this compilation unit.
 * <p>
 * If the compilation unit already includes the specified import declaration,
 * the import is not generated (it does not generate duplicates).
 * Note that it is valid to specify both a single-type import and an on-demand import
 * for the same package, for example <code>"java.io.File"</code> and
 * <code>"java.io.*"</code>, in which case both are preserved since the semantics
 * of this are not the same as just importing <code>"java.io.*"</code>.
 * Importing <code>"java.lang.*"</code>, or the package in which the compilation unit
 * is defined, are not treated as special cases.  If they are specified, they are
 * included in the result.
 * <p>
 * Note: This API element is only needed for dealing with Java code that uses
 * new language features of J2SE 5.0.
 * </p>
 *
 * @param name the name of the import declaration to add as defined by JLS2 7.5. (For example: <code>"java.io.File"</code> or
 *  <code>"java.awt.*"</code>)
 * @param sibling the existing element which the import declaration will be inserted immediately before (if
 *	<code> null </code>, then this import will be inserted as the last import declaration.
 * @param flags {@link Flags#AccStatic} for static imports, or
 * {@link Flags#AccDefault} for regular imports; other modifier flags
 * are ignored
 * @param monitor the progress monitor to notify
 * @return the newly inserted import declaration (or the previously existing one in case attempting to create a duplicate)
 *
 * @throws JavaModelException if the element could not be created. Reasons include:
 * <ul>
 * <li> This Java element does not exist or the specified sibling does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * <li> A {@link org.eclipse.core.runtime.CoreException} occurred while updating an underlying resource
 * <li> The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 * <li> The name is not a valid import name (INVALID_NAME)
 * </ul>
 * @see Flags
 * @since 3.0
 */
IImportDeclaration createImport(String name, IJavaElement sibling, int flags, IProgressMonitor monitor) throws JavaModelException;

Creates and returns a package declaration in this compilation unit
with the given package name.
If the compilation unit already includes the specified package declaration,
it is not generated (it does not generate duplicates).
Params: name – the name of the package declaration to add as defined by JLS2 7.4. (For example, "java.lang")
monitor – the progress monitor to notify
Throws: JavaModelException – if the element could not be created. Reasons include:

This Java element does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource 
 The name is not a valid package name (INVALID_NAME)
Returns: the newly inserted package declaration (or the previously existing one in case attempting to create a duplicate)/**
 * Creates and returns a package declaration in this compilation unit
 * with the given package name.
 *
 * <p>If the compilation unit already includes the specified package declaration,
 * it is not generated (it does not generate duplicates).
 *
 * @param name the name of the package declaration to add as defined by JLS2 7.4. (For example, <code>"java.lang"</code>)
 * @param monitor the progress monitor to notify
 * @return the newly inserted package declaration (or the previously existing one in case attempting to create a duplicate)
 *
 * @throws JavaModelException if the element could not be created. Reasons include:
 * <ul>
 * <li>This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * <li> A {@link org.eclipse.core.runtime.CoreException} occurred while updating an underlying resource
 * <li> The name is not a valid package name (INVALID_NAME)
 * </ul>
 */
 IPackageDeclaration createPackageDeclaration(String name, IProgressMonitor monitor) throws JavaModelException;
Creates and returns a type in this compilation unit with the
given contents. If this compilation unit does not exist, one
will be created with an appropriate package declaration.

Optionally, the new type can be positioned before the specified
sibling. If sibling is null, the type will be appended
to the end of this compilation unit.
It is possible that a type with the same name already exists in this compilation unit.
The value of the force parameter affects the resolution of
such a conflict:

 true - in this case the type is created with the new contents
 false - in this case a JavaModelException is thrown

Params: contents – the source contents of the type declaration to add.
sibling – the existing element which the type will be inserted immediately before (if
null, then this type will be inserted as the last type declaration.
force – a boolean flag indicating how to deal with duplicates
monitor – the progress monitor to notify
Throws: JavaModelException – if the element could not be created. Reasons include:

The specified sibling element does not exist (ELEMENT_DOES_NOT_EXIST)
 A CoreException occurred while updating an underlying resource 
 The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 The contents could not be recognized as a type declaration (INVALID_CONTENTS)
 There was a naming collision with an existing type (NAME_COLLISION)
Returns: the newly inserted type/**
 * Creates and returns a type in this compilation unit with the
 * given contents. If this compilation unit does not exist, one
 * will be created with an appropriate package declaration.
 * <p>
 * Optionally, the new type can be positioned before the specified
 * sibling. If <code>sibling</code> is <code>null</code>, the type will be appended
 * to the end of this compilation unit.
 *
 * <p>It is possible that a type with the same name already exists in this compilation unit.
 * The value of the <code>force</code> parameter affects the resolution of
 * such a conflict:<ul>
 * <li> <code>true</code> - in this case the type is created with the new contents</li>
 * <li> <code>false</code> - in this case a {@link JavaModelException} is thrown</li>
 * </ul>
 *
 * @param contents the source contents of the type declaration to add.
 * @param sibling the existing element which the type will be inserted immediately before (if
 *	<code>null</code>, then this type will be inserted as the last type declaration.
 * @param force a <code>boolean</code> flag indicating how to deal with duplicates
 * @param monitor the progress monitor to notify
 * @return the newly inserted type
 *
 * @throws JavaModelException if the element could not be created. Reasons include:
 * <ul>
 * <li>The specified sibling element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * <li> A {@link org.eclipse.core.runtime.CoreException} occurred while updating an underlying resource
 * <li> The specified sibling is not a child of this compilation unit (INVALID_SIBLING)
 * <li> The contents could not be recognized as a type declaration (INVALID_CONTENTS)
 * <li> There was a naming collision with an existing type (NAME_COLLISION)
 * </ul>
 */
IType createType(String contents, IJavaElement sibling, boolean force, IProgressMonitor monitor) throws JavaModelException;
Changes this compilation unit in working copy mode back to its original mode.

This has no effect if this compilation unit was not in working copy mode.

 If becomeWorkingCopy(IProgressMonitor) method was called several times on this compilation unit, discardWorkingCopy() must be called as many times before it switches back to the original mode. Same as for method getWorkingCopy(IProgressMonitor). 
Throws: JavaModelException – if this working copy could not return in its original mode.
See Also: becomeWorkingCopy(IProblemRequestor, IProgressMonitor)
Since: 3.0/**
 * Changes this compilation unit in working copy mode back to its original mode.
 * <p>
 * This has no effect if this compilation unit was not in working copy mode.
 * </p>
 * <p>
 * If {@link #becomeWorkingCopy(IProgressMonitor)} method was called several
 * times on this compilation unit, {@link #discardWorkingCopy()} must be called
 * as many times before it switches back to the original mode. Same as
 * for method {@link #getWorkingCopy(IProgressMonitor)}.
 * </p>
 *
 * @throws JavaModelException if this working copy could not return in its original mode.
 * @see #becomeWorkingCopy(IProblemRequestor, IProgressMonitor)
 * @since 3.0
 */
void discardWorkingCopy() throws JavaModelException;
Finds the elements in this compilation unit that correspond to
the given element.
An element A corresponds to an element B if:

A has the same element name as B.
If A is a method, A must have the same number of arguments as
    B and the simple names of the argument types must be equals.
The parent of A corresponds to the parent of B recursively up to
    their respective compilation units.
A exists.

Returns null for the following cases:

if no such java elements can be found or if the given element is not included in this compilation unit
the element is a lambda expression, i.e. calling IType.isLambda() returns true
the element is an ILocalVariable

Params: element – the given element
Returns: the found elements in this compilation unit that correspond to the given element
Since: 3.0/**
 * Finds the elements in this compilation unit that correspond to
 * the given element.
 * An element A corresponds to an element B if:
 * <ul>
 * <li>A has the same element name as B.
 * <li>If A is a method, A must have the same number of arguments as
 *     B and the simple names of the argument types must be equals.
 * <li>The parent of A corresponds to the parent of B recursively up to
 *     their respective compilation units.
 * <li>A exists.
 * </ul>
 * Returns <code>null</code> for the following cases:
 * <ul>
 * <li>if no such java elements can be found or if the given element is not included in this compilation unit</li>
 * <li>the element is a lambda expression, i.e. calling {@link IType#isLambda()} returns true</li>
 * <li>the element is an {@link ILocalVariable}</li>
 * </ul>
 *
 * @param element the given element
 * @return the found elements in this compilation unit that correspond to the given element
 * @since 3.0
 */
@Override
IJavaElement[] findElements(IJavaElement element);
Finds the working copy for this compilation unit, given a WorkingCopyOwner. If no working copy has been created for this compilation unit associated with this working copy owner, returns null.

Users of this method must not destroy the resulting working copy.
Params: owner – the given WorkingCopyOwner
See Also: WorkingCopyOwner
Returns: the found working copy for this compilation unit, null if none
Since: 3.0/**
 * Finds the working copy for this compilation unit, given a {@link WorkingCopyOwner}.
 * If no working copy has been created for this compilation unit associated with this
 * working copy owner, returns <code>null</code>.
 * <p>
 * Users of this method must not destroy the resulting working copy.
 *
 * @param owner the given {@link WorkingCopyOwner}
 * @return the found working copy for this compilation unit, <code>null</code> if none
 * @see WorkingCopyOwner
 * @since 3.0
 */
ICompilationUnit findWorkingCopy(WorkingCopyOwner owner);
Returns all types declared in this compilation unit in the order
in which they appear in the source.
This includes all top-level types and nested member types.
It does NOT include local types (types defined in methods).
Throws: JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource
Returns: the array of top-level and member types defined in a compilation unit, in declaration order./**
 * Returns all types declared in this compilation unit in the order
 * in which they appear in the source.
 * This includes all top-level types and nested member types.
 * It does NOT include local types (types defined in methods).
 *
 * @return the array of top-level and member types defined in a compilation unit, in declaration order.
 * @throws JavaModelException if this element does not exist or if an
 *		exception occurs while accessing its corresponding resource
 */
IType[] getAllTypes() throws JavaModelException;
Returns the first import declaration in this compilation unit with the given name.
This is a handle-only method. The import declaration may or may not exist. This
is a convenience method - imports can also be accessed from a compilation unit's
import container.
Params: name – the name of the import to find as defined by JLS2 7.5. (For example: "java.io.File"
	or "java.awt.*")
Returns: a handle onto the corresponding import declaration. The import declaration may or may not exist./**
 * Returns the first import declaration in this compilation unit with the given name.
 * This is a handle-only method. The import declaration may or may not exist. This
 * is a convenience method - imports can also be accessed from a compilation unit's
 * import container.
 *
 * @param name the name of the import to find as defined by JLS2 7.5. (For example: <code>"java.io.File"</code>
 * 	or <code>"java.awt.*"</code>)
 * @return a handle onto the corresponding import declaration. The import declaration may or may not exist.
 */
IImportDeclaration getImport(String name) ;
Returns the import container for this compilation unit.
This is a handle-only method. The import container may or
may not exist. The import container can used to access the
imports.
Returns: a handle onto the corresponding import container. The
	import contain may or may not exist./**
 * Returns the import container for this compilation unit.
 * This is a handle-only method. The import container may or
 * may not exist. The import container can used to access the
 * imports.
 * @return a handle onto the corresponding import container. The
 *		import contain may or may not exist.
 */
IImportContainer getImportContainer();
Returns the import declarations in this compilation unit
in the order in which they appear in the source. This is
a convenience method - import declarations can also be
accessed from a compilation unit's import container.
Throws: JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource
Returns: the import declarations in this compilation unit/**
 * Returns the import declarations in this compilation unit
 * in the order in which they appear in the source. This is
 * a convenience method - import declarations can also be
 * accessed from a compilation unit's import container.
 *
 * @return the import declarations in this compilation unit
 * @throws JavaModelException if this element does not exist or if an
 *		exception occurs while accessing its corresponding resource
 */
IImportDeclaration[] getImports() throws JavaModelException;
Returns the primary compilation unit (whose owner is the primary owner)
this working copy was created from, or this compilation unit if this a primary
compilation unit.

Note that the returned primary compilation unit can be in working copy mode.

Returns: the primary compilation unit this working copy was created from,
or this compilation unit if it is primary
Since: 3.0/**
 * Returns the primary compilation unit (whose owner is the primary owner)
 * this working copy was created from, or this compilation unit if this a primary
 * compilation unit.
 * <p>
 * Note that the returned primary compilation unit can be in working copy mode.
 * </p>
 *
 * @return the primary compilation unit this working copy was created from,
 * or this compilation unit if it is primary
 * @since 3.0
 */
ICompilationUnit getPrimary();
Returns null if this ICompilationUnit is the primary
working copy, or this ICompilationUnit is not a working copy,
otherwise the WorkingCopyOwner
Returns: null if this ICompilationUnit is the primary
working copy, or this ICompilationUnit is not a working copy,
otherwise the WorkingCopyOwner
Since: 3.0/**
 * Returns <code>null</code> if this <code>ICompilationUnit</code> is the primary
 * working copy, or this <code>ICompilationUnit</code> is not a working copy,
 * otherwise the <code>WorkingCopyOwner</code>
 * 
 * @return <code>null</code> if this <code>ICompilationUnit</code> is the primary
 * working copy, or this <code>ICompilationUnit</code> is not a working copy,
 * otherwise the <code>WorkingCopyOwner</code>
 * @since 3.0
 */
WorkingCopyOwner getOwner();
Returns the first package declaration in this compilation unit with the given package name
(there normally is at most one package declaration).
This is a handle-only method. The package declaration may or may not exist.
Params: name – the name of the package declaration as defined by JLS2 7.4. (For example, "java.lang")
Returns: the first package declaration in this compilation unit with the given package name/**
 * Returns the first package declaration in this compilation unit with the given package name
 * (there normally is at most one package declaration).
 * This is a handle-only method. The package declaration may or may not exist.
 *
 * @param name the name of the package declaration as defined by JLS2 7.4. (For example, <code>"java.lang"</code>)
 * @return the first package declaration in this compilation unit with the given package name
 */
IPackageDeclaration getPackageDeclaration(String name);
Returns the package declarations in this compilation unit
in the order in which they appear in the source.
There normally is at most one package declaration.
Throws: JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource
Returns: an array of package declaration (normally of size one)/**
 * Returns the package declarations in this compilation unit
 * in the order in which they appear in the source.
 * There normally is at most one package declaration.
 *
 * @return an array of package declaration (normally of size one)
 *
 * @throws JavaModelException if this element does not exist or if an
 *		exception occurs while accessing its corresponding resource
 */
IPackageDeclaration[] getPackageDeclarations() throws JavaModelException;
Returns the top-level type declared in this compilation unit with the given simple type name.
The type name has to be a valid compilation unit name.
This is a handle-only method. The type may or may not exist.
Params: name – the simple name of the requested type in the compilation unit
See Also: JavaConventions.validateCompilationUnitName(String name, String sourceLevel, String complianceLevel)
Returns: a handle onto the corresponding type. The type may or may not exist./**
 * Returns the top-level type declared in this compilation unit with the given simple type name.
 * The type name has to be a valid compilation unit name.
 * This is a handle-only method. The type may or may not exist.
 *
 * @param name the simple name of the requested type in the compilation unit
 * @return a handle onto the corresponding type. The type may or may not exist.
 * @see JavaConventions#validateCompilationUnitName(String name, String sourceLevel, String complianceLevel)
 */
IType getType(String name);
Returns the top-level types declared in this compilation unit
in the order in which they appear in the source.
Throws: JavaModelException – if this element does not exist or if an
	exception occurs while accessing its corresponding resource
Returns: the top-level types declared in this compilation unit/**
 * Returns the top-level types declared in this compilation unit
 * in the order in which they appear in the source.
 *
 * @return the top-level types declared in this compilation unit
 * @throws JavaModelException if this element does not exist or if an
 *		exception occurs while accessing its corresponding resource
 */
IType[] getTypes() throws JavaModelException;
Returns a new working copy of this compilation unit if it is a primary compilation unit,
or this compilation unit if it is already a non-primary working copy.
 Note: if intending to share a working copy amongst several clients, then getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor) should be used instead. 

When the working copy instance is created, an ADDED IJavaElementDelta is
reported on this working copy.
 Once done with the working copy, users of this method must discard it using discardWorkingCopy(). 

Since 2.1, a working copy can be created on a not-yet existing compilation
unit. In particular, such a working copy can then be committed in order to create
the corresponding compilation unit.

Params: monitor – a progress monitor used to report progress while opening this compilation unit
                or null if no progress should be reported
Throws: JavaModelException – if the contents of this element can
  not be determined.
Returns: a new working copy of this element if this element is not
a working copy, or this element if this element is already a working copy
Since: 3.0/**
 * Returns a new working copy of this compilation unit if it is a primary compilation unit,
 * or this compilation unit if it is already a non-primary working copy.
 * <p>
 * Note: if intending to share a working copy amongst several clients, then
 * {@link #getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)}
 * should be used instead.
 * </p><p>
 * When the working copy instance is created, an ADDED IJavaElementDelta is
 * reported on this working copy.
 * </p><p>
 * Once done with the working copy, users of this method must discard it using
 * {@link #discardWorkingCopy()}.
 * </p><p>
 * Since 2.1, a working copy can be created on a not-yet existing compilation
 * unit. In particular, such a working copy can then be committed in order to create
 * the corresponding compilation unit.
 * </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 the contents of this element can
 *   not be determined.
 * @return a new working copy of this element if this element is not
 * a working copy, or this element if this element is already a working copy
 * @since 3.0
 */
ICompilationUnit getWorkingCopy(IProgressMonitor monitor) throws JavaModelException;
Returns a shared working copy on this compilation unit using the given working copy owner to create the buffer, or this compilation unit if it is already a non-primary working copy. This API can only answer an already existing working copy if it is based on the same original compilation unit AND was using the same working copy owner (that is, as defined by Object.equals). 
The life time of a shared working copy is as follows:

The first call to getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor) creates a new working copy for this element
Subsequent calls increment an internal counter.
A call to discardWorkingCopy() decrements the internal counter.
When this counter is 0, the working copy is discarded.

So users of this method must discard exactly once the working copy.

Note that the working copy owner will be used for the life time of this working copy, that is if the
working copy is closed then reopened, this owner will be used.
The buffer will be automatically initialized with the original's compilation unit content
upon creation.

When the shared working copy instance is created, an ADDED IJavaElementDelta is reported on this
working copy.

Since 2.1, a working copy can be created on a not-yet existing compilation
unit. In particular, such a working copy can then be committed in order to create
the corresponding compilation unit.

Params: owner – the working copy owner that creates a buffer that is used to get the content
				of the working copy
problemRequestor – a requestor which will get notified of problems detected during
	reconciling as they are discovered. The requestor can be set to null indicating
	that the client is not interested in problems.
monitor – a progress monitor used to report progress while opening this compilation unit
                or null if no progress should be reported
Throws: JavaModelException – if the contents of this element can
  not be determined.
Returns: a new working copy of this element using the given factory to create
the buffer, or this element if this element is already a working copy
Since: 3.0
Deprecated: Use ITypeRoot.getWorkingCopy(WorkingCopyOwner, IProgressMonitor) instead. Note that if this deprecated method is used, problems will be reported on the passed problem requester as well as on the problem requestor returned by the working copy owner (if not null)./**
 * Returns a shared working copy on this compilation unit using the given working copy owner to create
 * the buffer, or this compilation unit if it is already a non-primary working copy.
 * This API can only answer an already existing working copy if it is based on the same
 * original compilation unit AND was using the same working copy owner (that is, as defined by {@link Object#equals}).
 * <p>
 * The life time of a shared working copy is as follows:
 * <ul>
 * <li>The first call to {@link #getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)}
 * 	creates a new working copy for this element</li>
 * <li>Subsequent calls increment an internal counter.</li>
 * <li>A call to {@link #discardWorkingCopy()} decrements the internal counter.</li>
 * <li>When this counter is 0, the working copy is discarded.
 * </ul>
 * So users of this method must discard exactly once the working copy.
 * <p>
 * Note that the working copy owner will be used for the life time of this working copy, that is if the
 * working copy is closed then reopened, this owner will be used.
 * The buffer will be automatically initialized with the original's compilation unit content
 * upon creation.
 * <p>
 * When the shared working copy instance is created, an ADDED IJavaElementDelta is reported on this
 * working copy.
 * </p><p>
 * Since 2.1, a working copy can be created on a not-yet existing compilation
 * unit. In particular, such a working copy can then be committed in order to create
 * the corresponding compilation unit.
 * </p>
 * @param owner the working copy owner that creates a buffer that is used to get the content
 * 				of the working copy
 * @param problemRequestor a requestor which will get notified of problems detected during
 * 	reconciling as they are discovered. The requestor can be set to <code>null</code> indicating
 * 	that the client is not interested in problems.
 * @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 the contents of this element can
 *   not be determined.
 * @return a new working copy of this element using the given factory to create
 * the buffer, or this element if this element is already a working copy
 * @since 3.0
 * @deprecated Use {@link ITypeRoot#getWorkingCopy(WorkingCopyOwner, IProgressMonitor)} instead.
 * 	Note that if this deprecated method is used, problems will be reported on the passed problem requester
 * 	as well as on the problem requestor returned by the working copy owner (if not null).
 */
ICompilationUnit getWorkingCopy(WorkingCopyOwner owner, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException;
Returns whether the resource of this working copy has changed since the
inception of this working copy.
Returns false if this compilation unit is not in working copy mode.
Returns: whether the resource has changed
Since: 3.0/**
 * Returns whether the resource of this working copy has changed since the
 * inception of this working copy.
 * Returns <code>false</code> if this compilation unit is not in working copy mode.
 *
 * @return whether the resource has changed
 * @since 3.0
 */
public boolean hasResourceChanged();
Returns whether this element is a working copy.
Returns: true if this element is a working copy, false otherwise
Since: 3.0/**
 * Returns whether this element is a working copy.
 *
 * @return true if this element is a working copy, false otherwise
 * @since 3.0
 */
@Override
boolean isWorkingCopy();

Reconciles the contents of this working copy, sends out a Java delta notification indicating the nature of the change of the working copy since the last time it was either reconciled or made consistent (IOpenable.makeConsistent(IProgressMonitor)), and returns a compilation unit AST if requested. 
It performs the reconciliation by locally caching the contents of
the working copy, updating the contents, then creating a delta
over the cached contents and the new contents, and finally firing
this delta.

The boolean argument allows to force problem detection even if the
working copy is already consistent.


This functionality allows to specify a working copy owner which is used
during problem detection. All references contained in the working copy are
resolved against other units; for which corresponding owned working copies
are going to take precedence over their original compilation units. If
null is passed in, then the primary working copy owner is used.

 Compilation problems found in the new contents are notified through the IProblemRequestor interface which was passed at creation, and no longer as transient markers. 

Note: Since 3.0, added/removed/changed inner types generate change deltas.


If requested, a DOM AST representing the compilation unit is returned.
Its bindings are computed only if the problem requestor is active.
This method returns null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced

 This method doesn't perform statements recovery. To recover statements with syntax errors, reconcile(int, boolean, boolean, WorkingCopyOwner, IProgressMonitor) must be use. 
Params: astLevel – either NO_AST if no AST is wanted, or the AST API level of the AST if one is wanted
forceProblemDetection – boolean indicating whether problem should be
  recomputed even if the source hasn't changed
owner – the owner of working copies that take precedence over the
  original compilation units, or null if the primary working
  copy owner should be used
monitor – a progress monitor
Throws: JavaModelException – if the contents of the original element
	cannot be accessed. Reasons include:

 The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the compilation unit AST or null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced
Since: 3.0/**
 * Reconciles the contents of this working copy, sends out a Java delta
 * notification indicating the nature of the change of the working copy since
 * the last time it was either reconciled or made consistent
 * ({@link IOpenable#makeConsistent(IProgressMonitor)}), and returns a
 * compilation unit AST if requested.
 * <p>
 * It performs the reconciliation by locally caching the contents of
 * the working copy, updating the contents, then creating a delta
 * over the cached contents and the new contents, and finally firing
 * this delta.
 * <p>
 * The boolean argument allows to force problem detection even if the
 * working copy is already consistent.
 * </p>
 * <p>
 * This functionality allows to specify a working copy owner which is used
 * during problem detection. All references contained in the working copy are
 * resolved against other units; for which corresponding owned working copies
 * are going to take precedence over their original compilation units. If
 * <code>null</code> is passed in, then the primary working copy owner is used.
 * </p>
 * <p>
 * Compilation problems found in the new contents are notified through the
 * {@link IProblemRequestor} interface which was passed at
 * creation, and no longer as transient markers.
 * </p>
 * <p>
 * Note: Since 3.0, added/removed/changed inner types generate change deltas.
 * </p>
 * <p>
 * If requested, a DOM AST representing the compilation unit is returned.
 * Its bindings are computed only if the problem requestor is active.
 * This method returns <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 * <p>
 * This method doesn't perform statements recovery. To recover statements with syntax
 * errors, {@link #reconcile(int, boolean, boolean, WorkingCopyOwner, IProgressMonitor)} must be use.
 * </p>
 *
 * @param astLevel either {@link #NO_AST} if no AST is wanted,
 * or the {@linkplain AST#newAST(int, boolean) AST API level} of the AST if one is wanted
 * @param forceProblemDetection boolean indicating whether problem should be
 *   recomputed even if the source hasn't changed
 * @param owner the owner of working copies that take precedence over the
 *   original compilation units, or <code>null</code> if the primary working
 *   copy owner should be used
 * @param monitor a progress monitor
 * @return the compilation unit AST or <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 * @throws JavaModelException if the contents of the original element
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @since 3.0
 */
CompilationUnit reconcile(int astLevel, boolean forceProblemDetection, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException;

Reconciles the contents of this working copy, sends out a Java delta notification indicating the nature of the change of the working copy since the last time it was either reconciled or made consistent (IOpenable.makeConsistent(IProgressMonitor)), and returns a compilation unit AST if requested. 
It performs the reconciliation by locally caching the contents of
the working copy, updating the contents, then creating a delta
over the cached contents and the new contents, and finally firing
this delta.

The boolean argument allows to force problem detection even if the
working copy is already consistent.


This functionality allows to specify a working copy owner which is used
during problem detection. All references contained in the working copy are
resolved against other units; for which corresponding owned working copies
are going to take precedence over their original compilation units. If
null is passed in, then the primary working copy owner is used.

 Compilation problems found in the new contents are notified through the IProblemRequestor interface which was passed at creation, and no longer as transient markers. 

Note: Since 3.0, added/removed/changed inner types generate change deltas.


If requested, a DOM AST representing the compilation unit is returned.
Its bindings are computed only if the problem requestor is active.
This method returns null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced


If statements recovery is enabled then this method tries to rebuild statements
with syntax error. Otherwise statements with syntax error won't be present in
the returning DOM AST.

Params: astLevel – either NO_AST if no AST is wanted, or the AST API level of the AST if one is wanted
forceProblemDetection – boolean indicating whether problem should be
  recomputed even if the source hasn't changed
enableStatementsRecovery – if true statements recovery is enabled.
owner – the owner of working copies that take precedence over the
  original compilation units, or null if the primary working
  copy owner should be used
monitor – a progress monitor
Throws: JavaModelException – if the contents of the original element
	cannot be accessed. Reasons include:

 The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the compilation unit AST or null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced
Since: 3.2/**
 * Reconciles the contents of this working copy, sends out a Java delta
 * notification indicating the nature of the change of the working copy since
 * the last time it was either reconciled or made consistent
 * ({@link IOpenable#makeConsistent(IProgressMonitor)}), and returns a
 * compilation unit AST if requested.
 * <p>
 * It performs the reconciliation by locally caching the contents of
 * the working copy, updating the contents, then creating a delta
 * over the cached contents and the new contents, and finally firing
 * this delta.
 * <p>
 * The boolean argument allows to force problem detection even if the
 * working copy is already consistent.
 * </p>
 * <p>
 * This functionality allows to specify a working copy owner which is used
 * during problem detection. All references contained in the working copy are
 * resolved against other units; for which corresponding owned working copies
 * are going to take precedence over their original compilation units. If
 * <code>null</code> is passed in, then the primary working copy owner is used.
 * </p>
 * <p>
 * Compilation problems found in the new contents are notified through the
 * {@link IProblemRequestor} interface which was passed at
 * creation, and no longer as transient markers.
 * </p>
 * <p>
 * Note: Since 3.0, added/removed/changed inner types generate change deltas.
 * </p>
 * <p>
 * If requested, a DOM AST representing the compilation unit is returned.
 * Its bindings are computed only if the problem requestor is active.
 * This method returns <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 *
 * <p>
 * If statements recovery is enabled then this method tries to rebuild statements
 * with syntax error. Otherwise statements with syntax error won't be present in
 * the returning DOM AST.
 * </p>
 *
 * @param astLevel either {@link #NO_AST} if no AST is wanted,
 * or the {@linkplain AST#newAST(int, boolean) AST API level} of the AST if one is wanted
 * @param forceProblemDetection boolean indicating whether problem should be
 *   recomputed even if the source hasn't changed
 * @param enableStatementsRecovery if <code>true</code> statements recovery is enabled.
 * @param owner the owner of working copies that take precedence over the
 *   original compilation units, or <code>null</code> if the primary working
 *   copy owner should be used
 * @param monitor a progress monitor
 * @return the compilation unit AST or <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 * @throws JavaModelException if the contents of the original element
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @since 3.2
 */
CompilationUnit reconcile(int astLevel, boolean forceProblemDetection, boolean enableStatementsRecovery, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException;

Reconciles the contents of this working copy, sends out a Java delta notification indicating the nature of the change of the working copy since the last time it was either reconciled or made consistent (IOpenable.makeConsistent(IProgressMonitor)), and returns a compilation unit AST if requested.  If the problem detection is forced by passing the FORCE_PROBLEM_DETECTION bit in the given reconcile flag, problem detection is run even if the working copy is already consistent. 

It performs the reconciliation by locally caching the contents of
the working copy, updating the contents, then creating a delta
over the cached contents and the new contents, and finally firing
this delta.

This functionality allows to specify a working copy owner which is used
during problem detection. All references contained in the working copy are
resolved against other units; for which corresponding owned working copies
are going to take precedence over their original compilation units. If
null is passed in, then the primary working copy owner is used.

 Compilation problems found in the new contents are notified through the IProblemRequestor interface which was passed at creation, and no longer as transient markers. 

Note: Since 3.0, added/removed/changed inner types generate change deltas.


If requested, a DOM AST representing the compilation unit is returned.
Its bindings are computed only if the problem requestor is active.
This method returns null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced

 If statements recovery is enabled by passing the ENABLE_STATEMENTS_RECOVERY bit in the given reconcile flag then this method tries to rebuild statements with syntax error. Otherwise statements with syntax error won't be present in the returning DOM AST.
 If bindings recovery is enabled by passing the ENABLE_BINDINGS_RECOVERY bit in the given reconcile flag then this method tries to resolve bindings even if the type resolution contains errors.
 The given reconcile flags is a bit-mask of the different constants (ENABLE_BINDINGS_RECOVERY, ENABLE_STATEMENTS_RECOVERY, FORCE_PROBLEM_DETECTION). Unspecified values are left for future use. 
Params: astLevel – either NO_AST if no AST is wanted, or the AST API level of the AST if one is wanted
reconcileFlags – the given reconcile flags
owner – the owner of working copies that take precedence over the
  original compilation units, or null if the primary working
  copy owner should be used
monitor – a progress monitor
Throws: JavaModelException – if the contents of the original element
	cannot be accessed. Reasons include:

 The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)
See Also: FORCE_PROBLEM_DETECTION
ENABLE_BINDINGS_RECOVERY
ENABLE_STATEMENTS_RECOVERY
Returns: the compilation unit AST or null if one of the following conditions is true:

  the creation of the DOM AST is not requested
  the requested level of AST API is not supported
  the working copy was already consistent and problem detection is not forced
Since: 3.3/**
 * Reconciles the contents of this working copy, sends out a Java delta
 * notification indicating the nature of the change of the working copy since
 * the last time it was either reconciled or made consistent
 * ({@link IOpenable#makeConsistent(IProgressMonitor)}), and returns a
 * compilation unit AST if requested.
 *
 * <p>
 * If the problem detection is forced by passing the {@link #FORCE_PROBLEM_DETECTION} bit in the given reconcile flag,
 * problem detection is run even if the working copy is already consistent.
 * </p>
 *
 * <p>
 * It performs the reconciliation by locally caching the contents of
 * the working copy, updating the contents, then creating a delta
 * over the cached contents and the new contents, and finally firing
 * this delta.</p>
 *
 * <p>
 * This functionality allows to specify a working copy owner which is used
 * during problem detection. All references contained in the working copy are
 * resolved against other units; for which corresponding owned working copies
 * are going to take precedence over their original compilation units. If
 * <code>null</code> is passed in, then the primary working copy owner is used.
 * </p>
 * <p>
 * Compilation problems found in the new contents are notified through the
 * {@link IProblemRequestor} interface which was passed at
 * creation, and no longer as transient markers.
 * </p>
 * <p>
 * Note: Since 3.0, added/removed/changed inner types generate change deltas.
 * </p>
 * <p>
 * If requested, a DOM AST representing the compilation unit is returned.
 * Its bindings are computed only if the problem requestor is active.
 * This method returns <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 *
 * <p>
 * If statements recovery is enabled by passing the {@link #ENABLE_STATEMENTS_RECOVERY} bit in the given reconcile flag
 * then this method tries to rebuild statements with syntax error. Otherwise statements with syntax error won't be
 * present in the returning DOM AST.</p>
 * <p>
 * If bindings recovery is enabled by passing the {@link #ENABLE_BINDINGS_RECOVERY} bit in the given reconcile flag
 * then this method tries to resolve bindings even if the type resolution contains errors.</p>
 * <p>
 * The given reconcile flags is a bit-mask of the different constants ({@link #ENABLE_BINDINGS_RECOVERY},
 * {@link #ENABLE_STATEMENTS_RECOVERY}, {@link #FORCE_PROBLEM_DETECTION}). Unspecified values are left for future use.
 * </p>
 *
 * @param astLevel either {@link #NO_AST} if no AST is wanted,
 * or the {@linkplain AST#newAST(int, boolean) AST API level} of the AST if one is wanted
 * @param reconcileFlags the given reconcile flags
 * @param owner the owner of working copies that take precedence over the
 *   original compilation units, or <code>null</code> if the primary working
 *   copy owner should be used
 * @param monitor a progress monitor
 * @return the compilation unit AST or <code>null</code> if one of the following conditions is true:
 * <ul>
 *   <li>the creation of the DOM AST is not requested</li>
 *   <li>the requested level of AST API is not supported</li>
 *   <li>the working copy was already consistent and problem detection is not forced</li>
 * </ul>
 * @throws JavaModelException if the contents of the original element
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @see #FORCE_PROBLEM_DETECTION
 * @see #ENABLE_BINDINGS_RECOVERY
 * @see #ENABLE_STATEMENTS_RECOVERY
 * @since 3.3
 */
CompilationUnit reconcile(int astLevel, int reconcileFlags, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException;

Restores the contents of this working copy to the current contents of
this working copy's original element. Has no effect if this element
is not a working copy.
Note: This is the inverse of committing the content of the working copy to the original element with commitWorkingCopy(boolean, IProgressMonitor). 
Throws: JavaModelException – if the contents of the original element
	cannot be accessed.  Reasons include:

 The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)
Since: 3.0/**
 * Restores the contents of this working copy to the current contents of
 * this working copy's original element. Has no effect if this element
 * is not a working copy.
 *
 * <p>Note: This is the inverse of committing the content of the
 * working copy to the original element with {@link #commitWorkingCopy(boolean, IProgressMonitor)}.
 *
 * @throws JavaModelException if the contents of the original element
 *		cannot be accessed.  Reasons include:
 * <ul>
 * <li> The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @since 3.0
 */
@Override
void restore() throws JavaModelException;
}

See Also:	setStatementsRecovery.setStatementsRecovery(boolean)
Since:	3.3

See Also:	setBindingsRecovery.setBindingsRecovery(boolean) IBinding.isRecovered()
Since:	3.3

See Also:	setIgnoreMethodBodies.setIgnoreMethodBodies(boolean)
Since:	3.5.2

Params:	edit – the edit to apply monitor – the progress monitor to use or `null` if no progress should be reported
Throws:	JavaModelException – if this edit can not be applied to the compilation unit's buffer. Reasons include: This compilation unit does not exist (`IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST`). The provided edit can not be applied as there is a problem with the text edit locations (`IJavaModelStatusConstants.BAD_TEXT_EDIT_LOCATION`).
Returns:	the undo edit
Since:	3.4

Params:	problemRequestor – a requestor which will get notified of problems detected during reconciling as they are discovered. The requestor can be set to `null` indicating that the client is not interested in problems. monitor – a progress monitor used to report progress while opening this compilation unit or `null` if no progress should be reported
Throws:	JavaModelException – if this compilation unit could not become a working copy.
See Also:	discardWorkingCopy()
Since:	3.0
Deprecated:	Use `becomeWorkingCopy(IProgressMonitor)` instead. Note that if this deprecated method is used, problems will be reported to the given problem requestor as well as the problem requestor returned by the working copy owner (if not null).

Params:	monitor – a progress monitor used to report progress while opening this compilation unit or `null` if no progress should be reported
Throws:	JavaModelException – if this compilation unit could not become a working copy.
See Also:	discardWorkingCopy()
Since:	3.3

Params:	force – a flag to handle the cases when the contents of the original resource have changed since this working copy was created monitor – the given progress monitor
Throws:	JavaModelException – if this working copy could not commit. Reasons include: A `CoreException` occurred while updating an underlying resource This element is not a working copy (INVALID_ELEMENT_TYPES) A update conflict (described above) (UPDATE_CONFLICT)
Since:	3.0

Params:	name – the name of the import declaration to add as defined by JLS2 7.5. (For example: `"java.io.File"` or `"java.awt.*"`) sibling – the existing element which the import declaration will be inserted immediately before (if `null` , then this import will be inserted as the last import declaration. monitor – the progress monitor to notify
Throws:	JavaModelException – if the element could not be created. Reasons include: This Java element does not exist or the specified sibling does not exist (ELEMENT_DOES_NOT_EXIST) A `CoreException` occurred while updating an underlying resource The specified sibling is not a child of this compilation unit (INVALID_SIBLING) The name is not a valid import name (INVALID_NAME)
See Also:	createImport(String, IJavaElement, int, IProgressMonitor)
Returns:	the newly inserted import declaration (or the previously existing one in case attempting to create a duplicate)

Params:	name – the name of the package declaration to add as defined by JLS2 7.4. (For example, `"java.lang"`) monitor – the progress monitor to notify
Throws:	JavaModelException – if the element could not be created. Reasons include: This Java element does not exist (ELEMENT_DOES_NOT_EXIST) A `CoreException` occurred while updating an underlying resource The name is not a valid package name (INVALID_NAME)
Returns:	the newly inserted package declaration (or the previously existing one in case attempting to create a duplicate)

Params:	contents – the source contents of the type declaration to add. sibling – the existing element which the type will be inserted immediately before (if `null`, then this type will be inserted as the last type declaration. force – a `boolean` flag indicating how to deal with duplicates monitor – the progress monitor to notify
Throws:	JavaModelException – if the element could not be created. Reasons include: The specified sibling element does not exist (ELEMENT_DOES_NOT_EXIST) A `CoreException` occurred while updating an underlying resource The specified sibling is not a child of this compilation unit (INVALID_SIBLING) The contents could not be recognized as a type declaration (INVALID_CONTENTS) There was a naming collision with an existing type (NAME_COLLISION)
Returns:	the newly inserted type

Params:	element – the given element
Returns:	the found elements in this compilation unit that correspond to the given element
Since:	3.0

Params:	owner – the given `WorkingCopyOwner`
See Also:	WorkingCopyOwner
Returns:	the found working copy for this compilation unit, `null` if none
Since:	3.0

Throws:	JavaModelException – if this element does not exist or if an exception occurs while accessing its corresponding resource
Returns:	the array of top-level and member types defined in a compilation unit, in declaration order.

Params:	name – the name of the import to find as defined by JLS2 7.5. (For example: `"java.io.File"` or `"java.awt.*"`)
Returns:	a handle onto the corresponding import declaration. The import declaration may or may not exist.

Returns:	the primary compilation unit this working copy was created from, or this compilation unit if it is primary
Since:	3.0

Returns:	`null` if this `ICompilationUnit` is the primary working copy, or this `ICompilationUnit` is not a working copy, otherwise the `WorkingCopyOwner`
Since:	3.0

Params:	name – the simple name of the requested type in the compilation unit
See Also:	JavaConventions.validateCompilationUnitName(String name, String sourceLevel, String complianceLevel)
Returns:	a handle onto the corresponding type. The type may or may not exist.

Params:	owner – the working copy owner that creates a buffer that is used to get the content of the working copy problemRequestor – a requestor which will get notified of problems detected during reconciling as they are discovered. The requestor can be set to `null` indicating that the client is not interested in problems. monitor – a progress monitor used to report progress while opening this compilation unit or `null` if no progress should be reported
Throws:	JavaModelException – if the contents of this element can not be determined.
Returns:	a new working copy of this element using the given factory to create the buffer, or this element if this element is already a working copy
Since:	3.0
Deprecated:	Use `ITypeRoot.getWorkingCopy(WorkingCopyOwner, IProgressMonitor)` instead. Note that if this deprecated method is used, problems will be reported on the passed problem requester as well as on the problem requestor returned by the working copy owner (if not null).

Returns:	true if this element is a working copy, false otherwise
Since:	3.0

Params:	astLevel – either `NO_AST` if no AST is wanted, or the AST API level of the AST if one is wanted forceProblemDetection – boolean indicating whether problem should be recomputed even if the source hasn't changed owner – the owner of working copies that take precedence over the original compilation units, or `null` if the primary working copy owner should be used monitor – a progress monitor
Throws:	JavaModelException – if the contents of the original element cannot be accessed. Reasons include: The original Java element does not exist (ELEMENT_DOES_NOT_EXIST)
Returns:	the compilation unit AST or `null` if one of the following conditions is true: the creation of the DOM AST is not requested the requested level of AST API is not supported the working copy was already consistent and problem detection is not forced
Since:	3.0

/

org.eclipse.jdt/ org.eclipse.jdt.core/ 3.20.0/ org/eclipse/jdt/core/ICompilationUnit.java