org.eclipse.jdt/org.eclipse.jdt.core/3.20.0 : org/eclipse/jdt/core/compiler/ReconcileContext.java

ReconcileContext
http://www.eclipse.org/jdt: Java Development Tools Core (Eclipse Foundation)
Eclipse Public License - v 2.0
Copyright (c) 2005, 2016 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:
   mkaufman@bea.com - initial API and implementation
   IBM - renamed from PreReconcileCompilationResult to ReconcileContext
   IBM - rewrote spec
/*******************************************************************************
 * Copyright (c) 2005, 2016 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:
 *    mkaufman@bea.com - initial API and implementation
 *    IBM - renamed from PreReconcileCompilationResult to ReconcileContext
 *    IBM - rewrote spec
 *
 *******************************************************************************/

package org.eclipse.jdt.core.compiler;

import java.util.HashMap;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElementDelta;
import org.eclipse.jdt.core.IJavaModelMarker;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.ReconcileWorkingCopyOperation;

The context of a reconcile event that is notified to interested compilation
participants while a reconcile operation is running.
 A reconcile participant can get the AST for the reconcile-operation using getAST4(). If the participant modifies in any way the AST (either by modifying the source of the working copy, or modifying another entity that would result in different bindings for the AST), it is expected to reset the AST in the context using resetAST(). 
 A reconcile participant can also create and return problems using putProblems(String, CategorizedProblem[]). These problems are then reported to the problem requestor of the reconcile operation. 
See Also: CompilationParticipant.reconcile(ReconcileContext)
Since: 3.2
@noinstantiate This class is not intended to be instantiated by clients.
@noextend This class is not intended to be subclassed by clients./**
 * The context of a reconcile event that is notified to interested compilation
 * participants while a reconcile operation is running.
 * <p>
 * A reconcile participant can get the AST for the reconcile-operation using
 * {@link #getAST4()}. If the participant modifies in any way the AST
 * (either by modifying the source of the working copy, or modifying another entity
 * that would result in different bindings for the AST), it is expected to reset the
 * AST in the context using {@link #resetAST()}.
 * </p><p>
 * A reconcile participant can also create and return problems using
 * {@link #putProblems(String, CategorizedProblem[])}. These problems are then reported
 * to the problem requestor of the reconcile operation.
 * </p>
 *
 * @see CompilationParticipant#reconcile(ReconcileContext)
 * @since 3.2
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
@SuppressWarnings({"rawtypes"})
public class ReconcileContext {

	private ReconcileWorkingCopyOperation operation;
	private CompilationUnit workingCopy;

Creates a reconcile context for the given reconcile operation.
Params: operation – the reconcile operation
@noreference This constructor is not intended to be called by clients./**
 * Creates a reconcile context for the given reconcile operation.
 *
 * @param operation the reconcile operation
 * @noreference This constructor is not intended to be called by clients.
 */
public ReconcileContext(ReconcileWorkingCopyOperation operation, CompilationUnit workingCopy) {
	this.operation = operation;
	this.workingCopy = workingCopy;
}

Returns a resolved AST with JLS3 level. It is created from the current state of the working copy. Creates one if none exists yet. Returns null if the current state of the working copy
doesn't allow the AST to be created (e.g. if the working copy's content
cannot be parsed).
 If the AST level requested during reconciling is not AST.JLS3 or if binding resolutions was not requested, then a different AST is created. Note that this AST does not become the current AST and it is only valid for the requestor. 
Throws: JavaModelException –  if the contents of the working copy
	cannot be accessed. Reasons include:

 The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the AST created from the current state of the working copy,
  or null if none could be created
Deprecated: JLS3 has been deprecated. This method has been replaced by getAST4() which returns an AST with JLS4 level./**
 * Returns a resolved AST with {@link AST#JLS3 JLS3} level.
 * It is created from the current state of the working copy.
 * Creates one if none exists yet.
 * Returns <code>null</code> if the current state of the working copy
 * doesn't allow the AST to be created (e.g. if the working copy's content
 * cannot be parsed).
 * <p>
 * If the AST level requested during reconciling is not {@link AST#JLS3}
 * or if binding resolutions was not requested, then a different AST is created.
 * Note that this AST does not become the current AST and it is only valid for
 * the requestor.
 * </p>
 *
 * @return the AST created from the current state of the working copy,
 *   or <code>null</code> if none could be created
 * @exception JavaModelException  if the contents of the working copy
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The working copy does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @deprecated JLS3 has been deprecated. This method has been replaced by {@link #getAST4()} which returns an AST
 * with JLS4 level.
 */
public org.eclipse.jdt.core.dom.CompilationUnit getAST3() throws JavaModelException {
	return getAST(AST.JLS3);
}

Returns a resolved AST with JLS4 level. It is created from the current state of the working copy. Creates one if none exists yet. Returns null if the current state of the working copy
doesn't allow the AST to be created (e.g. if the working copy's content
cannot be parsed).
 If the AST level requested during reconciling is not AST.JLS4 or if binding resolutions was not requested, then a different AST is created. Note that this AST does not become the current AST and it is only valid for the requestor. 
Throws: JavaModelException –  if the contents of the working copy
	cannot be accessed. Reasons include:

 The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the AST created from the current state of the working copy,
  or null if none could be created
Deprecated: JLS4 has been deprecated. This method has been replaced by getAST8() which returns an AST with JLS8 level.
Since: 3.7.1/**
 * Returns a resolved AST with {@link AST#JLS4 JLS4} level.
 * It is created from the current state of the working copy.
 * Creates one if none exists yet.
 * Returns <code>null</code> if the current state of the working copy
 * doesn't allow the AST to be created (e.g. if the working copy's content
 * cannot be parsed).
 * <p>
 * If the AST level requested during reconciling is not {@link AST#JLS4}
 * or if binding resolutions was not requested, then a different AST is created.
 * Note that this AST does not become the current AST and it is only valid for
 * the requestor.
 * </p>
 *
 * @return the AST created from the current state of the working copy,
 *   or <code>null</code> if none could be created
 * @exception JavaModelException  if the contents of the working copy
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The working copy does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @deprecated JLS4 has been deprecated. This method has been replaced by {@link #getAST8()} which returns an AST
 * with JLS8 level.
 * @since 3.7.1
 */
public org.eclipse.jdt.core.dom.CompilationUnit getAST4() throws JavaModelException {
	return getAST(AST.JLS4);
}

Returns a resolved AST with JLS8 level. It is created from the current state of the working copy. Creates one if none exists yet. Returns null if the current state of the working copy
doesn't allow the AST to be created (e.g. if the working copy's content
cannot be parsed).
 If the AST level requested during reconciling is not AST.JLS8 or if binding resolutions was not requested, then a different AST is created. Note that this AST does not become the current AST and it is only valid for the requestor. 
Throws: JavaModelException –  if the contents of the working copy
	cannot be accessed. Reasons include:

 The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the AST created from the current state of the working copy,
  or null if none could be created
Deprecated: JLS8 has been deprecated. This method has been replaced by getAST(int) which returns an AST with the given level.
Since: 3.10/**
 * Returns a resolved AST with {@link AST#JLS8 JLS8} level.
 * It is created from the current state of the working copy.
 * Creates one if none exists yet.
 * Returns <code>null</code> if the current state of the working copy
 * doesn't allow the AST to be created (e.g. if the working copy's content
 * cannot be parsed).
 * <p>
 * If the AST level requested during reconciling is not {@link AST#JLS8}
 * or if binding resolutions was not requested, then a different AST is created.
 * Note that this AST does not become the current AST and it is only valid for
 * the requestor.
 * </p>
 *
 * @return the AST created from the current state of the working copy,
 *   or <code>null</code> if none could be created
 * @exception JavaModelException  if the contents of the working copy
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The working copy does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @deprecated JLS8 has been deprecated. This method has been replaced by {@link #getAST(int)} which returns an AST
 * with the given level.
 * @since 3.10
 */
public org.eclipse.jdt.core.dom.CompilationUnit getAST8() throws JavaModelException {
	return getAST(AST.JLS8);
}

Returns a resolved AST with the given AST level.
It is created from the current state of the working copy.
Creates one if none exists yet.
Returns null if the current state of the working copy
doesn't allow the AST to be created (e.g. if the working copy's content
cannot be parsed).

If the AST level requested during reconciling is not the latest available AST level
or if binding resolutions was not requested, then a different AST is created.
Note that this AST does not become the current AST and it is only valid for
the requestor.

Params: level – the API level; one of the .JLS* level constants declared on AST
Throws: JavaModelException –  if the contents of the working copy
	cannot be accessed. Reasons include:

 The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns: the AST created from the current state of the working copy,
  or null if none could be created
Since: 3.14/**
 * Returns a resolved AST with the given AST level.
 * It is created from the current state of the working copy.
 * Creates one if none exists yet.
 * Returns <code>null</code> if the current state of the working copy
 * doesn't allow the AST to be created (e.g. if the working copy's content
 * cannot be parsed).
 * <p>
 * If the AST level requested during reconciling is not the latest available AST level
 * or if binding resolutions was not requested, then a different AST is created.
 * Note that this AST does not become the current AST and it is only valid for
 * the requestor.
 * </p>
 *
 * @param level the API level; one of the <code>.JLS*</code> level constants
 * declared on {@link AST}
 * @return the AST created from the current state of the working copy,
 *   or <code>null</code> if none could be created
 * @exception JavaModelException  if the contents of the working copy
 *		cannot be accessed. Reasons include:
 * <ul>
 * <li> The working copy does not exist (ELEMENT_DOES_NOT_EXIST)</li>
 * </ul>
 * @since 3.14
 */
public org.eclipse.jdt.core.dom.CompilationUnit getAST(int level) throws JavaModelException {
	if (this.operation.astLevel != level || !this.operation.resolveBindings) {
		// create AST (optionally resolving bindings)
		ASTParser parser = ASTParser.newParser(level);
		parser.setCompilerOptions(this.workingCopy.getJavaProject().getOptions(true));
		if (JavaProject.hasJavaNature(this.workingCopy.getJavaProject().getProject()))
			parser.setResolveBindings(true);
		parser.setStatementsRecovery((this.operation.reconcileFlags & ICompilationUnit.ENABLE_STATEMENTS_RECOVERY) != 0);
		parser.setBindingsRecovery((this.operation.reconcileFlags & ICompilationUnit.ENABLE_BINDINGS_RECOVERY) != 0);
		parser.setSource(this.workingCopy);
		parser.setIgnoreMethodBodies((this.operation.reconcileFlags & ICompilationUnit.IGNORE_METHOD_BODIES) != 0);
		return (org.eclipse.jdt.core.dom.CompilationUnit) parser.createAST(this.operation.progressMonitor);
	}
	return this.operation.makeConsistent(this.workingCopy);
}

Returns the AST level requested by the reconcile operation. It is either ICompilationUnit.NO_AST, or one of the JLS constants defined on AST. 
Returns: the AST level requested by the reconcile operation/**
 * Returns the AST level requested by the reconcile operation.
 * It is either {@link ICompilationUnit#NO_AST}, or one of the JLS constants defined on {@link AST}.
 *
 * @return the AST level requested by the reconcile operation
 */
public int getASTLevel() {
	return this.operation.astLevel;
}

Returns whether the reconcile operation is resolving bindings.
Returns: whether the reconcile operation is resolving bindings/**
 * Returns whether the reconcile operation is resolving bindings.
 *
 * @return whether the reconcile operation is resolving bindings
 */
public boolean isResolvingBindings() {
	return this.operation.resolveBindings;
}
Returns the reconcile flag of this context. This flag is a bitwise value of the constant defined in ICompilationUnit. 
See Also: ICompilationUnit.ENABLE_BINDINGS_RECOVERY
ICompilationUnit.ENABLE_STATEMENTS_RECOVERY
ICompilationUnit.IGNORE_METHOD_BODIES
Returns: the reconcile flag of this context
Since: 3.6/**
 * Returns the reconcile flag of this context. This flag is a bitwise value of the constant defined
 * in {@link ICompilationUnit}.
 *
 * @return the reconcile flag of this context
 * @since 3.6
 *
 * @see ICompilationUnit#ENABLE_BINDINGS_RECOVERY
 * @see ICompilationUnit#ENABLE_STATEMENTS_RECOVERY
 * @see ICompilationUnit#IGNORE_METHOD_BODIES
 */
public int getReconcileFlags() {
	return this.operation.reconcileFlags;
}
Returns the delta describing the change to the working copy being reconciled.
Returns null if there is no change. Note that the delta's AST is not yet positioned at this stage. Use getAST4() to get the current AST. 
Returns: the delta describing the change, or null if none/**
 * Returns the delta describing the change to the working copy being reconciled.
 * Returns <code>null</code> if there is no change.
 * Note that the delta's AST is not yet positioned at this stage. Use {@link #getAST4()}
 * to get the current AST.
 *
 * @return the delta describing the change, or <code>null</code> if none
 */
public IJavaElementDelta getDelta() {
	return this.operation.deltaBuilder.delta;
}

Returns the problems to be reported to the problem requestor of the reconcile operation
for the given marker type.
Returns null if no problems need to be reported for this marker type.
Params: markerType – the given marker type
Returns: problems to be reported to the problem requestor/**
 * Returns the problems to be reported to the problem requestor of the reconcile operation
 * for the given marker type.
 * Returns <code>null</code> if no problems need to be reported for this marker type.
 *
 * @param markerType the given marker type
 * @return problems to be reported to the problem requestor
 */
public CategorizedProblem[] getProblems(String markerType) {
	if (this.operation.problems == null) return null;
	return (CategorizedProblem[]) this.operation.problems.get(markerType);
}

Returns the working copy this context refers to.
Returns: the working copy this context refers to/**
 * Returns the working copy this context refers to.
 *
 * @return the working copy this context refers to
 */
public ICompilationUnit getWorkingCopy() {
	return this.workingCopy;
}

Resets the AST carried by this context.
A compilation participant that modifies the environment that would result in different
bindings for the AST is expected to reset the AST on this context, so that other
participants don't get a stale AST.

Note that resetting the AST will not restart the reconcile process. Only further
participants will see the new AST. Thus participants running before the one that
resets the AST will have a stale view of the AST and its problems. Use
the compilation participant extension point to order the participants.

/**
 * Resets the AST carried by this context.
 * A compilation participant that modifies the environment that would result in different
 * bindings for the AST is expected to reset the AST on this context, so that other
 * participants don't get a stale AST.
 * <p>
 * Note that resetting the AST will not restart the reconcile process. Only further
 * participants will see the new AST. Thus participants running before the one that
 * resets the AST will have a stale view of the AST and its problems. Use
 * the compilation participant extension point to order the participants.
 * </p>
 */
public void resetAST() {
	this.operation.ast = null;
	putProblems(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, null);
	putProblems(IJavaModelMarker.TASK_MARKER, null);
}

Sets the problems to be reported to the problem requestor of the reconcile operation
for the given marker type.
null indicates that no problems need to be reported.

Using this functionality, a participant that resolves problems for a given marker type
can hide those problems since they don't exist any longer.

Params: markerType – the marker type of the given problems
problems –  the problems to be reported to the problem requestor of the reconcile operation,
  or null if none/**
 * Sets the problems to be reported to the problem requestor of the reconcile operation
 * for the given marker type.
 * <code>null</code> indicates that no problems need to be reported.
 * <p>
 * Using this functionality, a participant that resolves problems for a given marker type
 * can hide those problems since they don't exist any longer.
 * </p>
 *
 * @param markerType the marker type of the given problems
 * @param problems  the problems to be reported to the problem requestor of the reconcile operation,
 *   or <code>null</code> if none
 */
public void putProblems(String markerType, CategorizedProblem[] problems) {
	if (this.operation.problems == null)
		this.operation.problems = new HashMap();
	this.operation.problems.put(markerType, problems);
}

}
See Also:	CompilationParticipant.reconcile(ReconcileContext)
Since:	3.2
@noinstantiate	This class is not intended to be instantiated by clients.
@noextend	This class is not intended to be subclassed by clients.
Params:	operation – the reconcile operation
@noreference	This constructor is not intended to be called by clients.
Throws:	JavaModelException – if the contents of the working copy cannot be accessed. Reasons include: The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns:	the AST created from the current state of the working copy, or `null` if none could be created
Deprecated:	JLS3 has been deprecated. This method has been replaced by `getAST4()` which returns an AST with JLS4 level.
Params:	level – the API level; one of the `.JLS*` level constants declared on `AST`
Throws:	JavaModelException – if the contents of the working copy cannot be accessed. Reasons include: The working copy does not exist (ELEMENT_DOES_NOT_EXIST)
Returns:	the AST created from the current state of the working copy, or `null` if none could be created
Since:	3.14
See Also:	ICompilationUnit.ENABLE_BINDINGS_RECOVERY ICompilationUnit.ENABLE_STATEMENTS_RECOVERY ICompilationUnit.IGNORE_METHOD_BODIES
Returns:	the reconcile flag of this context
Since:	3.6
Params:	markerType – the given marker type
Returns:	problems to be reported to the problem requestor
/

org.eclipse.jdt/ org.eclipse.jdt.core/ 3.20.0/ org/eclipse/jdt/core/compiler/ReconcileContext.java
