Attachment #133308 for bug #272711

View | Details | Raw Unified | Return to bug 272711
Collapse All | Expand All

Lines 1048-1053 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTParser.java (+2 lines)
1048	converter.scanner = new RecoveryScanner(scanner, data.removeUnused());	1048	converter.scanner = new RecoveryScanner(scanner, data.removeUnused());
1049	converter.docParser.scanner = converter.scanner;	1049	converter.docParser.scanner = converter.scanner;
1050	converter.scanner.setSource(scanner.source);	1050	converter.scanner.setSource(scanner.source);
		1051
		1052	compilationUnit.setStatementsRecoveryData(data);
1051	}	1053	}
1052	RecordedParsingInformation recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;	1054	RecordedParsingInformation recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;
1053	int[][] comments = recordedParsingInformation.commentPositions;	1055	int[][] comments = recordedParsingInformation.commentPositions;

Lines 178-183 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnit.java (+32 lines)
178	* Problems reported by the compiler during parsing or name resolution.	178	* Problems reported by the compiler during parsing or name resolution.
179	*/	179	*/
180	private IProblem[] problems = EMPTY_PROBLEMS;	180	private IProblem[] problems = EMPTY_PROBLEMS;
		181
		182	/**
		183	* Internal data used to perform statements recovery.
		184	*/
		185	private Object statementsRecoveryData;
181		186
182	/**	187	/**
183	* The list of type declarations in textual order order;	188	* The list of type declarations in textual order order;
Lines 615-620 Link Here
615	}	620	}
616		621
617	/**	622	/**
		623	* Internal method
		624	*
		625	* This method return internal data used to perform statements recovery.
		626	*
		627	* @return internal data used to perform statements recovery.
		628	*
		629	* @noreference This method is not intended to be referenced by clients.
		630	* @since 3.5
		631	*/
		632	public Object getStatementsRecoveryData() {
		633	return this.statementsRecoveryData;
		634	}
		635
		636	/**
618	* The Java type root (a {@link org.eclipse.jdt.core.ICompilationUnit compilation unit} or a {@link org.eclipse.jdt.core.IClassFile class file})	637	* The Java type root (a {@link org.eclipse.jdt.core.ICompilationUnit compilation unit} or a {@link org.eclipse.jdt.core.IClassFile class file})
619	* this compilation unit was created from, or <code>null</code> if it was not created from a Java type root.	638	* this compilation unit was created from, or <code>null</code> if it was not created from a Java type root.
620	*	639	*
Lines 1009-1014 Link Here
1009	}	1028	}
1010	this.problems = problems;	1029	this.problems = problems;
1011	}	1030	}
		1031
		1032	/**
		1033	* Internal method
		1034	*
		1035	* Sets internal data used to perform statements recovery.
		1036	* @param data
		1037	*
		1038	* @noreference This method is not intended to be referenced by clients.
		1039	* @since 3.5
		1040	*/
		1041	void setStatementsRecoveryData(Object data) {
		1042	this.statementsRecoveryData = data;
		1043	}
1012		1044
1013	/* (omit javadoc for this method)	1045	/* (omit javadoc for this method)
1014	* Method declared on ASTNode.	1046	* Method declared on ASTNode.

Lines 1228-1233 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTConverter.java (+1 lines)
1228	this.compilationUnitSourceLength = source.length;	1228	this.compilationUnitSourceLength = source.length;
1229	this.scanner.setSource(source, unit.compilationResult);	1229	this.scanner.setSource(source, unit.compilationResult);
1230	CompilationUnit compilationUnit = new CompilationUnit(this.ast);	1230	CompilationUnit compilationUnit = new CompilationUnit(this.ast);
		1231	compilationUnit.setStatementsRecoveryData(unit.compilationResult.recoveryScannerData);
1231		1232
1232	// Parse comments	1233	// Parse comments
1233	int[][] comments = unit.comments;	1234	int[][] comments = unit.comments;

Lines 22-27 Link Here

(-)dom/org/eclipse/jdt/core/dom/InternalASTRewrite.java (-1 / +2 lines)
22	import org.eclipse.jdt.core.dom.SimplePropertyDescriptor;	22	import org.eclipse.jdt.core.dom.SimplePropertyDescriptor;
23	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;	23	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
24	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;	24	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
		25	import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
25	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer;	26	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer;
26	import org.eclipse.jdt.internal.core.dom.rewrite.LineInformation;	27	import org.eclipse.jdt.internal.core.dom.rewrite.LineInformation;
27	import org.eclipse.jdt.internal.core.dom.rewrite.ListRewriteEvent;	28	import org.eclipse.jdt.internal.core.dom.rewrite.ListRewriteEvent;
Lines 89-95 Link Here
89	String lineDelim= TextUtilities.getDefaultLineDelimiter(document);	90	String lineDelim= TextUtilities.getDefaultLineDelimiter(document);
90	List comments= rootNode.getCommentList();	91	List comments= rootNode.getCommentList();
91		92
92	ASTRewriteAnalyzer visitor = new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, comments, options, xsrComputer);	93	ASTRewriteAnalyzer visitor = new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, comments, options, xsrComputer, (RecoveryScannerData)rootNode.getStatementsRecoveryData());
93	rootNode.accept(visitor);	94	rootNode.accept(visitor);
94	}	95	}
95	return result;	96	return result;




				scanner.isTaskCaseSensitive);
		setData(data);
	}
	
	public RecoveryScanner(
			boolean tokenizeWhiteSpace,
			boolean checkNonExternalizedStringLiterals,
			long sourceLevel,
			long complianceLevel,
			char[][] taskTags,
			char[][] taskPriorities,
			boolean isTaskCaseSensitive,
			RecoveryScannerData data) {
		super(false,
				tokenizeWhiteSpace,
				checkNonExternalizedStringLiterals,
				sourceLevel,
				complianceLevel,
				taskTags,
				taskPriorities,
				isTaskCaseSensitive);
		setData(data);
	}

	public void insertToken(int token, int completedToken, int position) {
		insertTokens(new int []{token}, completedToken, position);




import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.IScanner;
import org.eclipse.jdt.core.compiler.ITerminalSymbols;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;

/**
 * Wraps a scanner and offers convenient methods for finding tokens

	public static final int LEXICAL_ERROR= 20002;
	public static final int DOCUMENT_ERROR= 20003;

	private final Scanner scanner;
	private final int endPosition;

	/**
	 * Creates a TokenScanner
	 * @param scanner The scanner to be wrapped
	 */
	public TokenScanner(Scanner scanner) {
		this.scanner= scanner;
		this.endPosition= this.scanner.getSource().length - 1;
	}

	 * Returns the wrapped scanner
	 * @return IScanner
	 */
	public Scanner getScanner() {
		return this.scanner;
	}


		do {
			try {
				curr= this.scanner.getNextToken();
				if (curr == TerminalTokens.TokenNameEOF) {
					throw new CoreException(createError(END_OF_FILE, "End Of File", null)); //$NON-NLS-1$
				}
			} catch (InvalidInputException e) {

	}

	public static boolean isComment(int token) {
		return token == TerminalTokens.TokenNameCOMMENT_BLOCK || token == TerminalTokens.TokenNameCOMMENT_JAVADOC
			|| token == TerminalTokens.TokenNameCOMMENT_LINE;
	}

	public static boolean isModifier(int token) {
		switch (token) {
			case TerminalTokens.TokenNamepublic:
			case TerminalTokens.TokenNameprotected:
			case TerminalTokens.TokenNameprivate:
			case TerminalTokens.TokenNamestatic:
			case TerminalTokens.TokenNamefinal:
			case TerminalTokens.TokenNameabstract:
			case TerminalTokens.TokenNamenative:
			case TerminalTokens.TokenNamevolatile:
			case TerminalTokens.TokenNamestrictfp:
			case TerminalTokens.TokenNametransient:
			case TerminalTokens.TokenNamesynchronized:
				return true;
			default:
				return false;

Lines 19-33 Link Here

(-)dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java (-70 / +111 lines)
19		19
20	import org.eclipse.core.runtime.Assert;	20	import org.eclipse.core.runtime.Assert;
21	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.jdt.core.ToolFactory;
23	import org.eclipse.jdt.core.compiler.IScanner;
24	import org.eclipse.jdt.core.compiler.ITerminalSymbols;
25	import org.eclipse.jdt.core.dom.*;	22	import org.eclipse.jdt.core.dom.*;
26	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;	23	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
27	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;	24	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;
28	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;	25	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
29	import org.eclipse.jdt.core.formatter.IndentManipulation;	26	import org.eclipse.jdt.core.formatter.IndentManipulation;
		27	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
		28	import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;
		29	import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
		30	import org.eclipse.jdt.internal.compiler.parser.Scanner;
30	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	31	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
		32	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
31	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;	33	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;
32	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.NodeMarker;	34	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.NodeMarker;
33	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.Prefix;	35	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.Prefix;
Lines 82-87 Link Here
82	private int beforeRequiredSpaceIndex = -1;	84	private int beforeRequiredSpaceIndex = -1;
83		85
84	Map options;	86	Map options;
		87
		88	private RecoveryScannerData recoveryScannerData;
85		89
86	/**	90	/**
87	* Constructor for ASTRewriteAnalyzer.	91	* Constructor for ASTRewriteAnalyzer.
Lines 91-100 Link Here
91	* @param eventStore the event store containing the description of changes	95	* @param eventStore the event store containing the description of changes
92	* @param nodeInfos annotations to nodes, such as if a node is a string placeholder or a copy target	96	* @param nodeInfos annotations to nodes, such as if a node is a string placeholder or a copy target
93	* @param comments list of comments of the compilation unit to rewrite (elements of type <code>Comment</code>) or <code>null</code>.	97	* @param comments list of comments of the compilation unit to rewrite (elements of type <code>Comment</code>) or <code>null</code>.
94	* @param options the current jdt.core options (formatting/compliance) or <code>null</code>.	98	* @param options the current jdt.core options (formatting/compliance) or <code>null</code>.
95	* @param extendedSourceRangeComputer the source range computer to use	99	* @param extendedSourceRangeComputer the source range computer to use
96	*/	100	* @param recoveryScannerData internal data used by {@link RecoveryScanner}
97	public ASTRewriteAnalyzer(char[] content, LineInformation lineInfo, String lineDelim, TextEdit rootEdit, RewriteEventStore eventStore, NodeInfoStore nodeInfos, List comments, Map options, TargetSourceRangeComputer extendedSourceRangeComputer) {	101	*/
		102	public ASTRewriteAnalyzer(
		103	char[] content,
		104	LineInformation lineInfo,
		105	String lineDelim,
		106	TextEdit rootEdit,
		107	RewriteEventStore eventStore,
		108	NodeInfoStore nodeInfos,
		109	List comments,
		110	Map options,
		111	TargetSourceRangeComputer extendedSourceRangeComputer,
		112	RecoveryScannerData recoveryScannerData) {
98	this.eventStore= eventStore;	113	this.eventStore= eventStore;
99	this.content= content;	114	this.content= content;
100	this.lineInfo= lineInfo;	115	this.lineInfo= lineInfo;
Lines 110-120 Link Here
110	this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);	125	this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
111		126
112	this.options = options;	127	this.options = options;
		128
		129	this.recoveryScannerData = recoveryScannerData;
113	}	130	}
114		131
115	final TokenScanner getScanner() {	132	final TokenScanner getScanner() {
116	if (this.tokenScanner == null) {	133	if (this.tokenScanner == null) {
117	IScanner scanner= ToolFactory.createScanner(true, false, false, false);	134	CompilerOptions compilerOptions = new CompilerOptions(this.options);
		135	Scanner scanner;
		136	if (this.recoveryScannerData == null) {
		137	scanner =
		138	new Scanner(
		139	true,/tokenizeComments/
		140	false,/tokenizeWhiteSpace/
		141	false,/checkNonExternalizedStringLiterals/
		142	compilerOptions.sourceLevel,
		143	compilerOptions.complianceLevel,
		144	null/taskTags/,
		145	null/taskPriorities/,
		146	true/taskCaseSensitive/);
		147	} else {
		148	scanner =
		149	new RecoveryScanner(
		150	false,/tokenizeWhiteSpace/
		151	false,/checkNonExternalizedStringLiterals/
		152	compilerOptions.sourceLevel,
		153	compilerOptions.complianceLevel,
		154	null/taskTags/,
		155	null/taskPriorities/,
		156	true/taskCaseSensitive/,
		157	this.recoveryScannerData);
		158	}
118	scanner.setSource(this.content);	159	scanner.setSource(this.content);
119	this.tokenScanner= new TokenScanner(scanner);	160	this.tokenScanner= new TokenScanner(scanner);
120	}	161	}
Lines 759-765 Link Here
759	try {	800	try {
760	ASTNode node= (ASTNode) event.getOriginalValue();	801	ASTNode node= (ASTNode) event.getOriginalValue();
761	TextEditGroup editGroup= getEditGroup(event);	802	TextEditGroup editGroup= getEditGroup(event);
762	int dotEnd= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, node.getStartPosition() + node.getLength());	803	int dotEnd= getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, node.getStartPosition() + node.getLength());
763	doTextRemoveAndVisit(startPos, dotEnd - startPos, node, editGroup);	804	doTextRemoveAndVisit(startPos, dotEnd - startPos, node, editGroup);
764	return dotEnd;	805	return dotEnd;
765	} catch (CoreException e) {	806	} catch (CoreException e) {
Lines 777-783 Link Here
777	doTextRemoveAndVisit(offset, length, node, editGroup);	818	doTextRemoveAndVisit(offset, length, node, editGroup);
778	doTextInsert(offset, (ASTNode) event.getNewValue(), getIndent(startPos), true, editGroup);	819	doTextInsert(offset, (ASTNode) event.getNewValue(), getIndent(startPos), true, editGroup);
779	try {	820	try {
780	return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, offset + length);	821	return getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, offset + length);
781	} catch (CoreException e) {	822	} catch (CoreException e) {
782	handleException(e);	823	handleException(e);
783	}	824	}
Lines 791-797 Link Here
791	}	832	}
792	int pos= doVisit((ASTNode) node);	833	int pos= doVisit((ASTNode) node);
793	try {	834	try {
794	return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, pos);	835	return getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, pos);
795	} catch (CoreException e) {	836	} catch (CoreException e) {
796	handleException(e);	837	handleException(e);
797	}	838	}
Lines 923-929 Link Here
923	}	964	}
924	boolean isAllRemoved= !isAllInserted && isAllOfKind(children, RewriteEvent.REMOVED);	965	boolean isAllRemoved= !isAllInserted && isAllOfKind(children, RewriteEvent.REMOVED);
925	if (isAllRemoved) { // all removed: set start to left bracket	966	if (isAllRemoved) { // all removed: set start to left bracket
926	int posBeforeOpenBracket= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameLESS, pos);	967	int posBeforeOpenBracket= getScanner().getTokenStartOffset(TerminalTokens.TokenNameLESS, pos);
927	if (posBeforeOpenBracket != pos) {	968	if (posBeforeOpenBracket != pos) {
928	needsSpaceOnRemoveAll= false;	969	needsSpaceOnRemoveAll= false;
929	}	970	}
Lines 931-937 Link Here
931	}	972	}
932	pos= new ListRewriter().rewriteList(parent, property, pos, String.valueOf('<'), ", "); //$NON-NLS-1$	973	pos= new ListRewriter().rewriteList(parent, property, pos, String.valueOf('<'), ", "); //$NON-NLS-1$
933	if (isAllRemoved) { // all removed: remove right and space up to next element	974	if (isAllRemoved) { // all removed: remove right and space up to next element
934	int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameGREATER, pos); // set pos to '>'	975	int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameGREATER, pos); // set pos to '>'
935	endPos= getScanner().getNextStartOffset(endPos, false);	976	endPos= getScanner().getNextStartOffset(endPos, false);
936	String replacement= needsSpaceOnRemoveAll ? String.valueOf(' ') : new String();	977	String replacement= needsSpaceOnRemoveAll ? String.valueOf(' ') : new String();
937	doTextReplace(pos, endPos - pos, replacement, getEditGroup(children[children.length - 1]));	978	doTextReplace(pos, endPos - pos, replacement, getEditGroup(children[children.length - 1]));
Lines 948-954 Link Here
948	}	989	}
949	if (pos != offset) { // list contained some type -> parse after closing bracket	990	if (pos != offset) { // list contained some type -> parse after closing bracket
950	try {	991	try {
951	return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameGREATER, pos);	992	return getScanner().getTokenEndOffset(TerminalTokens.TokenNameGREATER, pos);
952	} catch (CoreException e) {	993	} catch (CoreException e) {
953	handleException(e);	994	handleException(e);
954	}	995	}
Lines 1033-1039 Link Here
1033	try {	1074	try {
1034	getScanner().setOffset(pos);	1075	getScanner().setOffset(pos);
1035	for (int i= newDim; i < oldDim; i++) {	1076	for (int i= newDim; i < oldDim; i++) {
1036	getScanner().readToToken(ITerminalSymbols.TokenNameRBRACKET);	1077	getScanner().readToToken(TerminalTokens.TokenNameRBRACKET);
1037	}	1078	}
1038	doTextRemove(pos, getScanner().getCurrentEndOffset() - pos, editGroup);	1079	doTextRemove(pos, getScanner().getCurrentEndOffset() - pos, editGroup);
1039	} catch (CoreException e) {	1080	} catch (CoreException e) {
Lines 1048-1054 Link Here
1048	private int getPosAfterLeftBrace(int pos) {	1089	private int getPosAfterLeftBrace(int pos) {
1049	try {	1090	try {
1050	int nextToken= getScanner().readNext(pos, true);	1091	int nextToken= getScanner().readNext(pos, true);
1051	if (nextToken == ITerminalSymbols.TokenNameLBRACE) {	1092	if (nextToken == TerminalTokens.TokenNameLBRACE) {
1052	return getScanner().getCurrentEndOffset();	1093	return getScanner().getCurrentEndOffset();
1053	}	1094	}
1054	} catch (CoreException e) {	1095	} catch (CoreException e) {
Lines 1164-1180 Link Here
1164	}	1205	}
1165	boolean keep= true;	1206	boolean keep= true;
1166	switch (tok) {	1207	switch (tok) {
1167	case ITerminalSymbols.TokenNamepublic: keep= Modifier.isPublic(newModifiers); break;	1208	case TerminalTokens.TokenNamepublic: keep= Modifier.isPublic(newModifiers); break;
1168	case ITerminalSymbols.TokenNameprotected: keep= Modifier.isProtected(newModifiers); break;	1209	case TerminalTokens.TokenNameprotected: keep= Modifier.isProtected(newModifiers); break;
1169	case ITerminalSymbols.TokenNameprivate: keep= Modifier.isPrivate(newModifiers); break;	1210	case TerminalTokens.TokenNameprivate: keep= Modifier.isPrivate(newModifiers); break;
1170	case ITerminalSymbols.TokenNamestatic: keep= Modifier.isStatic(newModifiers); break;	1211	case TerminalTokens.TokenNamestatic: keep= Modifier.isStatic(newModifiers); break;
1171	case ITerminalSymbols.TokenNamefinal: keep= Modifier.isFinal(newModifiers); break;	1212	case TerminalTokens.TokenNamefinal: keep= Modifier.isFinal(newModifiers); break;
1172	case ITerminalSymbols.TokenNameabstract: keep= Modifier.isAbstract(newModifiers); break;	1213	case TerminalTokens.TokenNameabstract: keep= Modifier.isAbstract(newModifiers); break;
1173	case ITerminalSymbols.TokenNamenative: keep= Modifier.isNative(newModifiers); break;	1214	case TerminalTokens.TokenNamenative: keep= Modifier.isNative(newModifiers); break;
1174	case ITerminalSymbols.TokenNamevolatile: keep= Modifier.isVolatile(newModifiers); break;	1215	case TerminalTokens.TokenNamevolatile: keep= Modifier.isVolatile(newModifiers); break;
1175	case ITerminalSymbols.TokenNamestrictfp: keep= Modifier.isStrictfp(newModifiers); break;	1216	case TerminalTokens.TokenNamestrictfp: keep= Modifier.isStrictfp(newModifiers); break;
1176	case ITerminalSymbols.TokenNametransient: keep= Modifier.isTransient(newModifiers); break;	1217	case TerminalTokens.TokenNametransient: keep= Modifier.isTransient(newModifiers); break;
1177	case ITerminalSymbols.TokenNamesynchronized: keep= Modifier.isSynchronized(newModifiers); break;	1218	case TerminalTokens.TokenNamesynchronized: keep= Modifier.isSynchronized(newModifiers); break;
1178	default:	1219	default:
1179	break loop;	1220	break loop;
1180	}	1221	}
Lines 1395-1401 Link Here
1395	boolean invertType= isChanged(node, TypeDeclaration.INTERFACE_PROPERTY);	1436	boolean invertType= isChanged(node, TypeDeclaration.INTERFACE_PROPERTY);
1396	if (invertType) {	1437	if (invertType) {
1397	try {	1438	try {
1398	int typeToken= isInterface ? ITerminalSymbols.TokenNameinterface : ITerminalSymbols.TokenNameclass;	1439	int typeToken= isInterface ? TerminalTokens.TokenNameinterface : TerminalTokens.TokenNameclass;
1399	getScanner().readToToken(typeToken, node.getStartPosition());	1440	getScanner().readToToken(typeToken, node.getStartPosition());
1400		1441
1401	String str= isInterface ? "class" : "interface"; //$NON-NLS-1$ //$NON-NLS-2$	1442	String str= isInterface ? "class" : "interface"; //$NON-NLS-1$ //$NON-NLS-2$
Lines 1544-1556 Link Here
1544	// parameters	1585	// parameters
1545	try {	1586	try {
1546	if (isChanged(node, MethodDeclaration.PARAMETERS_PROPERTY)) {	1587	if (isChanged(node, MethodDeclaration.PARAMETERS_PROPERTY)) {
1547	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	1588	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
1548	pos= rewriteNodeList(node, MethodDeclaration.PARAMETERS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	1589	pos= rewriteNodeList(node, MethodDeclaration.PARAMETERS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
1549	} else {	1590	} else {
1550	pos= doVisit(node, MethodDeclaration.PARAMETERS_PROPERTY, pos);	1591	pos= doVisit(node, MethodDeclaration.PARAMETERS_PROPERTY, pos);
1551	}	1592	}
1552		1593
1553	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);	1594	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
1554		1595
1555	int extraDims= rewriteExtraDimensions(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY, pos);	1596	int extraDims= rewriteExtraDimensions(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY, pos);
1556		1597
Lines 1561-1567 Link Here
1561	if ((extraDims > 0) && (hasExceptionChanges \|\| bodyChangeKind == RewriteEvent.INSERTED \|\| bodyChangeKind == RewriteEvent.REMOVED)) {	1602	if ((extraDims > 0) && (hasExceptionChanges \|\| bodyChangeKind == RewriteEvent.INSERTED \|\| bodyChangeKind == RewriteEvent.REMOVED)) {
1562	int dim= ((Integer) getOriginalValue(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY)).intValue();	1603	int dim= ((Integer) getOriginalValue(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY)).intValue();
1563	while (dim > 0) {	1604	while (dim > 0) {
1564	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, pos);	1605	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, pos);
1565	dim--;	1606	dim--;
1566	}	1607	}
1567	}	1608	}
Lines 1598-1604 Link Here
1598	*/	1639	*/
1599	public boolean visit(ReturnStatement node) {	1640	public boolean visit(ReturnStatement node) {
1600	try {	1641	try {
1601	this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamereturn, node.getStartPosition());	1642	this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(TerminalTokens.TokenNamereturn, node.getStartPosition());
1602		1643
1603	if (!hasChildrenChanges(node)) {	1644	if (!hasChildrenChanges(node)) {
1604	return doVisitUnchangedChildren(node);	1645	return doVisitUnchangedChildren(node);
Lines 1673-1679 Link Here
1673		1714
1674		1715
1675	try {	1716	try {
1676	int offset= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameLBRACKET, arrayType.getStartPosition());	1717	int offset= getScanner().getTokenStartOffset(TerminalTokens.TokenNameLBRACKET, arrayType.getStartPosition());
1677	// dimension node with expressions	1718	// dimension node with expressions
1678	RewriteEvent dimEvent= getEvent(node, ArrayCreation.DIMENSIONS_PROPERTY);	1719	RewriteEvent dimEvent= getEvent(node, ArrayCreation.DIMENSIONS_PROPERTY);
1679	boolean hasDimensionChanges= (dimEvent != null && dimEvent.getChangeKind() != RewriteEvent.UNCHANGED);	1720	boolean hasDimensionChanges= (dimEvent != null && dimEvent.getChangeKind() != RewriteEvent.UNCHANGED);
Lines 1692-1698 Link Here
1692	} else {	1733	} else {
1693	ASTNode elem= (ASTNode) event.getOriginalValue();	1734	ASTNode elem= (ASTNode) event.getOriginalValue();
1694	int elemEnd= elem.getStartPosition() + elem.getLength();	1735	int elemEnd= elem.getStartPosition() + elem.getLength();
1695	int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, elemEnd);	1736	int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, elemEnd);
1696	if (changeKind == RewriteEvent.REMOVED) {	1737	if (changeKind == RewriteEvent.REMOVED) {
1697	editGroup= getEditGroup(event);	1738	editGroup= getEditGroup(event);
1698	doTextRemoveAndVisit(offset, endPos - offset, elem, editGroup);	1739	doTextRemoveAndVisit(offset, endPos - offset, elem, editGroup);
Lines 1717-1730 Link Here
1717	}	1758	}
1718	if (nOldBrackets != nNewBrackets) {	1759	if (nOldBrackets != nNewBrackets) {
1719	if (!hasDimensionChanges) {	1760	if (!hasDimensionChanges) {
1720	offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, offset);	1761	offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, offset);
1721	}	1762	}
1722	rewriteExtraDimensions(nOldBrackets, nNewBrackets, offset, editGroup);	1763	rewriteExtraDimensions(nOldBrackets, nNewBrackets, offset, editGroup);
1723	}	1764	}
1724		1765
1725	int kind= getChangeKind(node, ArrayCreation.INITIALIZER_PROPERTY);	1766	int kind= getChangeKind(node, ArrayCreation.INITIALIZER_PROPERTY);
1726	if (kind == RewriteEvent.REMOVED) {	1767	if (kind == RewriteEvent.REMOVED) {
1727	offset= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, offset);	1768	offset= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, offset);
1728	} else {	1769	} else {
1729	offset= node.getStartPosition() + node.getLength(); // insert pos	1770	offset= node.getStartPosition() + node.getLength(); // insert pos
1730	}	1771	}
Lines 1838-1844 Link Here
1838	}	1879	}
1839		1880
1840	try {	1881	try {
1841	int offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamebreak, node.getStartPosition());	1882	int offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamebreak, node.getStartPosition());
1842	rewriteNode(node, BreakStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between break and label	1883	rewriteNode(node, BreakStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between break and label
1843	} catch (CoreException e) {	1884	} catch (CoreException e) {
1844	handleException(e);	1885	handleException(e);
Lines 1900-1906 Link Here
1900	} else {	1941	} else {
1901	if (isChanged(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY)) {	1942	if (isChanged(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY)) {
1902	try {	1943	try {
1903	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamenew, pos); //after 'new'	1944	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNamenew, pos); //after 'new'
1904	rewriteOptionalTypeParameters(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY, pos, " ", true, true); //$NON-NLS-1$	1945	rewriteOptionalTypeParameters(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY, pos, " ", true, true); //$NON-NLS-1$
1905	} catch (CoreException e) {	1946	} catch (CoreException e) {
1906	handleException(e);	1947	handleException(e);
Lines 1913-1919 Link Here
1913		1954
1914	if (isChanged(node, ClassInstanceCreation.ARGUMENTS_PROPERTY)) {	1955	if (isChanged(node, ClassInstanceCreation.ARGUMENTS_PROPERTY)) {
1915	try {	1956	try {
1916	int startpos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	1957	int startpos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
1917	rewriteNodeList(node, ClassInstanceCreation.ARGUMENTS_PROPERTY, startpos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	1958	rewriteNodeList(node, ClassInstanceCreation.ARGUMENTS_PROPERTY, startpos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
1918	} catch (CoreException e) {	1959	} catch (CoreException e) {
1919	handleException(e);	1960	handleException(e);
Lines 1925-1931 Link Here
1925	int kind= getChangeKind(node, ClassInstanceCreation.ANONYMOUS_CLASS_DECLARATION_PROPERTY);	1966	int kind= getChangeKind(node, ClassInstanceCreation.ANONYMOUS_CLASS_DECLARATION_PROPERTY);
1926	if (kind == RewriteEvent.REMOVED) {	1967	if (kind == RewriteEvent.REMOVED) {
1927	try {	1968	try {
1928	pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);	1969	pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
1929	} catch (CoreException e) {	1970	} catch (CoreException e) {
1930	handleException(e);	1971	handleException(e);
1931	}	1972	}
Lines 1962-1968 Link Here
1962	pos= rewriteOptionalTypeParameters(node, ConstructorInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$	2003	pos= rewriteOptionalTypeParameters(node, ConstructorInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$
1963	}	2004	}
1964	try {	2005	try {
1965	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	2006	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
1966	rewriteNodeList(node, ConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2007	rewriteNodeList(node, ConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
1967	} catch (CoreException e) {	2008	} catch (CoreException e) {
1968	handleException(e);	2009	handleException(e);
Lines 1979-1985 Link Here
1979	}	2020	}
1980		2021
1981	try {	2022	try {
1982	int offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamecontinue, node.getStartPosition());	2023	int offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamecontinue, node.getStartPosition());
1983	rewriteNode(node, ContinueStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between continue and label	2024	rewriteNode(node, ContinueStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between continue and label
1984	} catch (CoreException e) {	2025	} catch (CoreException e) {
1985	handleException(e);	2026	handleException(e);
Lines 1999-2008 Link Here
1999	try {	2040	try {
2000	RewriteEvent event= getEvent(node, DoStatement.BODY_PROPERTY);	2041	RewriteEvent event= getEvent(node, DoStatement.BODY_PROPERTY);
2001	if (event != null && event.getChangeKind() == RewriteEvent.REPLACED) {	2042	if (event != null && event.getChangeKind() == RewriteEvent.REPLACED) {
2002	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamedo, pos);	2043	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamedo, pos);
2003	ASTNode body= (ASTNode) event.getOriginalValue();	2044	ASTNode body= (ASTNode) event.getOriginalValue();
2004	int bodyEnd= body.getStartPosition() + body.getLength();	2045	int bodyEnd= body.getStartPosition() + body.getLength();
2005	int endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNamewhile, bodyEnd);	2046	int endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNamewhile, bodyEnd);
2006	rewriteBodyNode(node, DoStatement.BODY_PROPERTY, startOffset, endPos, getIndent(node.getStartPosition()), this.formatter.DO_BLOCK); // body	2047	rewriteBodyNode(node, DoStatement.BODY_PROPERTY, startOffset, endPos, getIndent(node.getStartPosition()), this.formatter.DO_BLOCK); // body
2007	} else {	2048	} else {
2008	voidVisit(node, DoStatement.BODY_PROPERTY);	2049	voidVisit(node, DoStatement.BODY_PROPERTY);
Lines 2085-2103 Link Here
2085		2126
2086	if (isChanged(node, ForStatement.INITIALIZERS_PROPERTY)) {	2127	if (isChanged(node, ForStatement.INITIALIZERS_PROPERTY)) {
2087	// position after opening parent	2128	// position after opening parent
2088	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	2129	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
2089	pos= rewriteNodeList(node, ForStatement.INITIALIZERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2130	pos= rewriteNodeList(node, ForStatement.INITIALIZERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2090	} else {	2131	} else {
2091	pos= doVisit(node, ForStatement.INITIALIZERS_PROPERTY, pos);	2132	pos= doVisit(node, ForStatement.INITIALIZERS_PROPERTY, pos);
2092	}	2133	}
2093		2134
2094	// position after first semicolon	2135	// position after first semicolon
2095	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);	2136	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameSEMICOLON, pos);
2096		2137
2097	pos= rewriteNode(node, ForStatement.EXPRESSION_PROPERTY, pos, ASTRewriteFormatter.NONE);	2138	pos= rewriteNode(node, ForStatement.EXPRESSION_PROPERTY, pos, ASTRewriteFormatter.NONE);
2098		2139
2099	if (isChanged(node, ForStatement.UPDATERS_PROPERTY)) {	2140	if (isChanged(node, ForStatement.UPDATERS_PROPERTY)) {
2100	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);	2141	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameSEMICOLON, pos);
2101	pos= rewriteNodeList(node, ForStatement.UPDATERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2142	pos= rewriteNodeList(node, ForStatement.UPDATERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2102	} else {	2143	} else {
2103	pos= doVisit(node, ForStatement.UPDATERS_PROPERTY, pos);	2144	pos= doVisit(node, ForStatement.UPDATERS_PROPERTY, pos);
Lines 2105-2111 Link Here
2105		2146
2106	RewriteEvent bodyEvent= getEvent(node, ForStatement.BODY_PROPERTY);	2147	RewriteEvent bodyEvent= getEvent(node, ForStatement.BODY_PROPERTY);
2107	if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {	2148	if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {
2108	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);	2149	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
2109	rewriteBodyNode(node, ForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body	2150	rewriteBodyNode(node, ForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body
2110	} else {	2151	} else {
2111	voidVisit(node, ForStatement.BODY_PROPERTY);	2152	voidVisit(node, ForStatement.BODY_PROPERTY);
Lines 2135-2141 Link Here
2135	if (thenEvent != null && thenEvent.getChangeKind() != RewriteEvent.UNCHANGED) {	2176	if (thenEvent != null && thenEvent.getChangeKind() != RewriteEvent.UNCHANGED) {
2136	try {	2177	try {
2137	int tok= getScanner().readNext(pos, true); // after the closing parent	2178	int tok= getScanner().readNext(pos, true); // after the closing parent
2138	pos= (tok == ITerminalSymbols.TokenNameRPAREN) ? getScanner().getCurrentEndOffset() : getScanner().getCurrentStartOffset();	2179	pos= (tok == TerminalTokens.TokenNameRPAREN) ? getScanner().getCurrentEndOffset() : getScanner().getCurrentStartOffset();
2139		2180
2140	int indent= getIndent(node.getStartPosition());	2181	int indent= getIndent(node.getStartPosition());
2141		2182
Lines 2143-2149 Link Here
2143	Object elseStatement= getOriginalValue(node, IfStatement.ELSE_STATEMENT_PROPERTY);	2184	Object elseStatement= getOriginalValue(node, IfStatement.ELSE_STATEMENT_PROPERTY);
2144	if (elseStatement != null) {	2185	if (elseStatement != null) {
2145	ASTNode thenStatement = (ASTNode) thenEvent.getOriginalValue();	2186	ASTNode thenStatement = (ASTNode) thenEvent.getOriginalValue();
2146	endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameelse, thenStatement.getStartPosition() + thenStatement.getLength()); // else keyword	2187	endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNameelse, thenStatement.getStartPosition() + thenStatement.getLength()); // else keyword
2147	}	2188	}
2148	if (elseStatement == null \|\| elseChange != RewriteEvent.UNCHANGED) {	2189	if (elseStatement == null \|\| elseChange != RewriteEvent.UNCHANGED) {
2149	pos= rewriteBodyNode(node, IfStatement.THEN_STATEMENT_PROPERTY, pos, endPos, indent, this.formatter.IF_BLOCK_NO_ELSE);	2190	pos= rewriteBodyNode(node, IfStatement.THEN_STATEMENT_PROPERTY, pos, endPos, indent, this.formatter.IF_BLOCK_NO_ELSE);
Lines 2182-2191 Link Here
2182	RewriteEvent event= getEvent(node, ImportDeclaration.STATIC_PROPERTY);	2223	RewriteEvent event= getEvent(node, ImportDeclaration.STATIC_PROPERTY);
2183	if (event != null && event.getChangeKind() != RewriteEvent.UNCHANGED) {	2224	if (event != null && event.getChangeKind() != RewriteEvent.UNCHANGED) {
2184	try {	2225	try {
2185	int pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameimport, node.getStartPosition());	2226	int pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameimport, node.getStartPosition());
2186	boolean wasStatic= ((Boolean) event.getOriginalValue()).booleanValue();	2227	boolean wasStatic= ((Boolean) event.getOriginalValue()).booleanValue();
2187	if (wasStatic) {	2228	if (wasStatic) {
2188	int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamestatic, pos);	2229	int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNamestatic, pos);
2189	doTextRemove(pos, endPos - pos, getEditGroup(event));	2230	doTextRemove(pos, endPos - pos, getEditGroup(event));
2190	} else {	2231	} else {
2191	doTextInsert(pos, " static", getEditGroup(event)); //$NON-NLS-1$	2232	doTextInsert(pos, " static", getEditGroup(event)); //$NON-NLS-1$
Lines 2205-2211 Link Here
2205	doTextInsert(pos, ".*", getEditGroup(event)); //$NON-NLS-1$	2246	doTextInsert(pos, ".*", getEditGroup(event)); //$NON-NLS-1$
2206	} else {	2247	} else {
2207	try {	2248	try {
2208	int endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);	2249	int endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNameSEMICOLON, pos);
2209	doTextRemove(pos, endPos - pos, getEditGroup(event));	2250	doTextRemove(pos, endPos - pos, getEditGroup(event));
2210	} catch (CoreException e) {	2251	} catch (CoreException e) {
2211	handleException(e);	2252	handleException(e);
Lines 2380-2386 Link Here
2380	if (isChanged(node, MethodInvocation.ARGUMENTS_PROPERTY)) {	2421	if (isChanged(node, MethodInvocation.ARGUMENTS_PROPERTY)) {
2381	// eval position after opening parent	2422	// eval position after opening parent
2382	try {	2423	try {
2383	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	2424	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
2384	rewriteNodeList(node, MethodInvocation.ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2425	rewriteNodeList(node, MethodInvocation.ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2385	} catch (CoreException e) {	2426	} catch (CoreException e) {
2386	handleException(e);	2427	handleException(e);
Lines 2557-2563 Link Here
2557	int kind= getChangeKind(node, SingleVariableDeclaration.INITIALIZER_PROPERTY);	2598	int kind= getChangeKind(node, SingleVariableDeclaration.INITIALIZER_PROPERTY);
2558	if (kind == RewriteEvent.REMOVED) {	2599	if (kind == RewriteEvent.REMOVED) {
2559	try {	2600	try {
2560	pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameEQUAL, pos);	2601	pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameEQUAL, pos);
2561	} catch (CoreException e) {	2602	} catch (CoreException e) {
2562	handleException(e);	2603	handleException(e);
2563	}	2604	}
Lines 2601-2607 Link Here
2601	if (isChanged(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY)) {	2642	if (isChanged(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY)) {
2602	// eval position after opening parent	2643	// eval position after opening parent
2603	try {	2644	try {
2604	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	2645	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
2605	rewriteNodeList(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2646	rewriteNodeList(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2606	} catch (CoreException e) {	2647	} catch (CoreException e) {
2607	handleException(e);	2648	handleException(e);
Lines 2638-2644 Link Here
2638	if (node.getAST().apiLevel() >= AST.JLS3) {	2679	if (node.getAST().apiLevel() >= AST.JLS3) {
2639	if (isChanged(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY)) {	2680	if (isChanged(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY)) {
2640	try {	2681	try {
2641	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, pos);	2682	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, pos);
2642	rewriteOptionalTypeParameters(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$	2683	rewriteOptionalTypeParameters(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$
2643	} catch (CoreException e) {	2684	} catch (CoreException e) {
2644	handleException(e);	2685	handleException(e);
Lines 2651-2657 Link Here
2651	if (isChanged(node, SuperMethodInvocation.ARGUMENTS_PROPERTY)) {	2692	if (isChanged(node, SuperMethodInvocation.ARGUMENTS_PROPERTY)) {
2652	// eval position after opening parent	2693	// eval position after opening parent
2653	try {	2694	try {
2654	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	2695	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
2655	rewriteNodeList(node, SuperMethodInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	2696	rewriteNodeList(node, SuperMethodInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2656	} catch (CoreException e) {	2697	} catch (CoreException e) {
2657	handleException(e);	2698	handleException(e);
Lines 2756-2762 Link Here
2756	ChildListPropertyDescriptor property= SwitchStatement.STATEMENTS_PROPERTY;	2797	ChildListPropertyDescriptor property= SwitchStatement.STATEMENTS_PROPERTY;
2757	if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {	2798	if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {
2758	try {	2799	try {
2759	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);	2800	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
2760	int insertIndent= getIndent(node.getStartPosition());	2801	int insertIndent= getIndent(node.getStartPosition());
2761	if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {	2802	if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {
2762	insertIndent++;	2803	insertIndent++;
Lines 2806-2812 Link Here
2806	*/	2847	*/
2807	public boolean visit(ThrowStatement node) {	2848	public boolean visit(ThrowStatement node) {
2808	try {	2849	try {
2809	this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamethrow, node.getStartPosition());	2850	this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(TerminalTokens.TokenNamethrow, node.getStartPosition());
2810		2851
2811	if (!hasChildrenChanges(node)) {	2852	if (!hasChildrenChanges(node)) {
2812	return doVisitUnchangedChildren(node);	2853	return doVisitUnchangedChildren(node);
Lines 2907-2913 Link Here
2907	int kind= getChangeKind(node, VariableDeclarationFragment.INITIALIZER_PROPERTY);	2948	int kind= getChangeKind(node, VariableDeclarationFragment.INITIALIZER_PROPERTY);
2908	if (kind == RewriteEvent.REMOVED) {	2949	if (kind == RewriteEvent.REMOVED) {
2909	try {	2950	try {
2910	pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameEQUAL, pos);	2951	pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameEQUAL, pos);
2911	} catch (CoreException e) {	2952	} catch (CoreException e) {
2912	handleException(e);	2953	handleException(e);
2913	}	2954	}
Lines 2952-2958 Link Here
2952		2993
2953	try {	2994	try {
2954	if (isChanged(node, WhileStatement.BODY_PROPERTY)) {	2995	if (isChanged(node, WhileStatement.BODY_PROPERTY)) {
2955	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);	2996	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
2956	rewriteBodyNode(node, WhileStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.WHILE_BLOCK); // body	2997	rewriteBodyNode(node, WhileStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.WHILE_BLOCK); // body
2957	} else {	2998	} else {
2958	voidVisit(node, WhileStatement.BODY_PROPERTY);	2999	voidVisit(node, WhileStatement.BODY_PROPERTY);
Lines 2990-2996 Link Here
2990	if (isChanged(node, MethodRef.PARAMETERS_PROPERTY)) {	3031	if (isChanged(node, MethodRef.PARAMETERS_PROPERTY)) {
2991	// eval position after opening parent	3032	// eval position after opening parent
2992	try {	3033	try {
2993	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	3034	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
2994	rewriteNodeList(node, MethodRef.PARAMETERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	3035	rewriteNodeList(node, MethodRef.PARAMETERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
2995	} catch (CoreException e) {	3036	} catch (CoreException e) {
2996	handleException(e);	3037	handleException(e);
Lines 3123-3129 Link Here
3123	try {	3164	try {
3124	int changeKind= getChangeKind(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY);	3165	int changeKind= getChangeKind(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY);
3125	if (changeKind == RewriteEvent.INSERTED \|\| changeKind == RewriteEvent.REMOVED) {	3166	if (changeKind == RewriteEvent.INSERTED \|\| changeKind == RewriteEvent.REMOVED) {
3126	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);	3167	pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
3127	}	3168	}
3128	rewriteNode(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY, pos, this.formatter.ANNOT_MEMBER_DEFAULT);	3169	rewriteNode(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY, pos, this.formatter.ANNOT_MEMBER_DEFAULT);
3129	} catch (CoreException e) {	3170	} catch (CoreException e) {
Lines 3146-3152 Link Here
3146	if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {	3187	if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {
3147	int startOffset;	3188	int startOffset;
3148	try {	3189	try {
3149	startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);	3190	startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
3150	rewriteBodyNode(node, EnhancedForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body	3191	rewriteBodyNode(node, EnhancedForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body
3151	} catch (CoreException e) {	3192	} catch (CoreException e) {
3152	handleException(e);	3193	handleException(e);
Lines 3172-3178 Link Here
3172	RewriteEvent[] children= argsEvent.getChildren();	3213	RewriteEvent[] children= argsEvent.getChildren();
3173	try {	3214	try {
3174	int nextTok= getScanner().readNext(pos, true);	3215	int nextTok= getScanner().readNext(pos, true);
3175	boolean hasParents= (nextTok == ITerminalSymbols.TokenNameLPAREN);	3216	boolean hasParents= (nextTok == TerminalTokens.TokenNameLPAREN);
3176	boolean isAllRemoved= hasParents && isAllOfKind(children, RewriteEvent.REMOVED);	3217	boolean isAllRemoved= hasParents && isAllOfKind(children, RewriteEvent.REMOVED);
3177	String prefix= ""; //$NON-NLS-1$	3218	String prefix= ""; //$NON-NLS-1$
3178	if (!hasParents) {	3219	if (!hasParents) {
Lines 3201-3207 Link Here
3201	if (kind == RewriteEvent.REMOVED) {	3242	if (kind == RewriteEvent.REMOVED) {
3202	try {	3243	try {
3203	// 'pos' can be before brace	3244	// 'pos' can be before brace
3204	pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);	3245	pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
3205	} catch (CoreException e) {	3246	} catch (CoreException e) {
3206	handleException(e);	3247	handleException(e);
3207	}	3248	}
Lines 3250-3256 Link Here
3250	indent= getIndent(node.getStartPosition()) + 1;	3291	indent= getIndent(node.getStartPosition()) + 1;
3251	}	3292	}
3252	int token= getScanner().readNext(pos, true);	3293	int token= getScanner().readNext(pos, true);
3253	boolean hasSemicolon= token == ITerminalSymbols.TokenNameSEMICOLON;	3294	boolean hasSemicolon= token == TerminalTokens.TokenNameSEMICOLON;
3254	if (!hasSemicolon && isAllOfKind(children, RewriteEvent.INSERTED)) {	3295	if (!hasSemicolon && isAllOfKind(children, RewriteEvent.INSERTED)) {
3255	if (!hasConstants) {	3296	if (!hasConstants) {
3256	String str= this.formatter.FIRST_ENUM_CONST.getPrefix(indent - 1);	3297	String str= this.formatter.FIRST_ENUM_CONST.getPrefix(indent - 1);
Lines 3316-3322 Link Here
3316	if (isChanged(node, NormalAnnotation.VALUES_PROPERTY)) {	3357	if (isChanged(node, NormalAnnotation.VALUES_PROPERTY)) {
3317	// eval position after opening parent	3358	// eval position after opening parent
3318	try {	3359	try {
3319	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);	3360	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
3320	rewriteNodeList(node, NormalAnnotation.VALUES_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	3361	rewriteNodeList(node, NormalAnnotation.VALUES_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
3321	} catch (CoreException e) {	3362	} catch (CoreException e) {
3322	handleException(e);	3363	handleException(e);
Lines 3337-3343 Link Here
3337	if (isChanged(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY)) {	3378	if (isChanged(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY)) {
3338	// eval position after opening parent	3379	// eval position after opening parent
3339	try {	3380	try {
3340	int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLESS, pos);	3381	int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLESS, pos);
3341	rewriteNodeList(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$	3382	rewriteNodeList(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
3342	} catch (CoreException e) {	3383	} catch (CoreException e) {
3343	handleException(e);	3384	handleException(e);




import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer;
import org.eclipse.jdt.internal.core.dom.rewrite.LineInformation;
import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;


		ASTNode astRoot= rootNode.getRoot();
		List commentNodes= astRoot instanceof CompilationUnit ? ((CompilationUnit) astRoot).getCommentList() : null;
		return internalRewriteAST(content, lineInfo, lineDelim, commentNodes, options, rootNode, (RecoveryScannerData)((CompilationUnit) astRoot).getStatementsRecoveryData());
	}

	/**

		String lineDelim= typeRoot.findRecommendedLineSeparator();
		Map options= typeRoot.getJavaProject().getOptions(true);

		return internalRewriteAST(content, lineInfo, lineDelim, astRoot.getCommentList(), options, rootNode, (RecoveryScannerData)astRoot.getStatementsRecoveryData());
	}

	private TextEdit internalRewriteAST(char[] content, LineInformation lineInfo, String lineDelim, List commentNodes, Map options, ASTNode rootNode, RecoveryScannerData recoveryScannerData) {
		TextEdit result= new MultiTextEdit();
		//validateASTNotModified(rootNode);

		TargetSourceRangeComputer sourceRangeComputer= getExtendedSourceRangeComputer();
		this.eventStore.prepareMovedNodes(sourceRangeComputer);

		ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, commentNodes, options, sourceRangeComputer, recoveryScannerData);
		rootNode.accept(visitor); // throws IllegalArgumentException

		this.eventStore.revertMovedNodes();

Lines 49-54 Link Here

(-)src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java (+6 lines)
49	suite.addTest(SourceModifierTest.allTests());	49	suite.addTest(SourceModifierTest.allTests());
50	suite.addTest(ImportRewriteTest.allTests());	50	suite.addTest(ImportRewriteTest.allTests());
51	suite.addTest(LineCommentOffsetsTest.allTests());	51	suite.addTest(LineCommentOffsetsTest.allTests());
		52	suite.addTest(ASTRewritingWithStatementsRecoveryTest.allTests());
52	return suite;	53	return suite;
53	}	54	}
54		55
Lines 97-105 Link Here
97	}	98	}
98		99
99	protected CompilationUnit createAST3(ICompilationUnit cu) {	100	protected CompilationUnit createAST3(ICompilationUnit cu) {
		101	return createAST3(cu, false);
		102	}
		103
		104	protected CompilationUnit createAST3(ICompilationUnit cu, boolean statementsRecovery) {
100	ASTParser parser= ASTParser.newParser(AST.JLS3);	105	ASTParser parser= ASTParser.newParser(AST.JLS3);
101	parser.setSource(cu);	106	parser.setSource(cu);
102	parser.setResolveBindings(false);	107	parser.setResolveBindings(false);
		108	parser.setStatementsRecovery(statementsRecovery);
103	return (CompilationUnit) parser.createAST(null);	109	return (CompilationUnit) parser.createAST(null);
104	}	110	}
105		111




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.rewrite.describing;
import java.util.List;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jdt.core.dom.*;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.ListRewrite;

public class ASTRewritingWithStatementsRecoveryTest extends ASTRewritingTest {
	private static final Class THIS= ASTRewritingWithStatementsRecoveryTest.class;

	public ASTRewritingWithStatementsRecoveryTest(String name) {
		super(name);
	}

	public static Test allTests() {
		return new Suite(THIS);
	}

	public static Test setUpTest(Test someTest) {
		TestSuite suite= new Suite("one test");
		suite.addTest(someTest);
		return suite;
	}

	public static Test suite() {
		return allTests();
	}

	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
	public void testBug272711_01() throws Exception {
		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        this.foo#3);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= createAST3(cu, true);
		AST ast= astRoot.getAST();
		ASTRewrite rewrite= ASTRewrite.create(ast);

		assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
		MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
		Block block= methodDecl.getBody();
		List statements= block.statements();
		assertTrue("Number of statements not 1", statements.size() == 1);
		{ // add type arguments
			ExpressionStatement stmt= (ExpressionStatement) statements.get(0);
			MethodInvocation invocation= (MethodInvocation) stmt.getExpression();
			ASTNode firstArgument = (ASTNode) invocation.arguments().get(0);
			NumberLiteral newNumberLiteral = ast.newNumberLiteral("0");
			ListRewrite listRewriter= rewrite.getListRewrite(invocation, MethodInvocation.ARGUMENTS_PROPERTY);
			listRewriter.replace(firstArgument, newNumberLiteral, null);
		}
		String preview= evaluateRewrite(cu, rewrite);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        this.foo#0);\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());

	}
	
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
	public void testBug272711_02() throws Exception {
		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        throws new UnsupportedOperationException();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= createAST3(cu, true);
		AST ast= astRoot.getAST();
		ASTRewrite rewrite= ASTRewrite.create(ast);

		assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
		List bodyDeclarations = type.bodyDeclarations();
		assertTrue("Number of body declarations not 1", bodyDeclarations.size() == 1);
		{ // add field declaration
			MethodDeclaration methodDeclaration =  (MethodDeclaration)bodyDeclarations.get(0);
			VariableDeclarationFragment newFragment = ast.newVariableDeclarationFragment();
			newFragment.setName(ast.newSimpleName("field"));
			FieldDeclaration newFieldDeclaration = ast.newFieldDeclaration(newFragment);
			newFieldDeclaration.setType(ast.newSimpleType(ast.newName("Object")));
			ListRewrite listRewriter= rewrite.getListRewrite(type, TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
			listRewriter.insertBefore(newFieldDeclaration, methodDeclaration, null);
		}
		String preview= evaluateRewrite(cu, rewrite);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    Object field;\n");
		buf.append("\n");
		buf.append("    public void foo() {\n");
		buf.append("        throws new UnsupportedOperationException();\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());

	}
	
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
	public void testBug272711_03() throws Exception {
		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        do {\n");
		buf.append("        } (a);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= createAST3(cu, true);
		AST ast= astRoot.getAST();
		ASTRewrite rewrite= ASTRewrite.create(ast);

		assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
		MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
		Block block= methodDecl.getBody();
		List statements= block.statements();
		assertTrue("Number of statements not 1", statements.size() == 1);
		{ // replace the 'a' simple name with another simple name
			DoStatement stmt= (DoStatement) statements.get(0);
			Statement body = stmt.getBody();
			EmptyStatement newEmptyStatement = ast.newEmptyStatement();
			rewrite.replace(body, newEmptyStatement, null);
		}
		String preview= evaluateRewrite(cu, rewrite);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo() {\n");
		buf.append("        do\n");
		buf.append("            ;  (a);\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());

	}

}

Return to bug 272711

Lines 39-44 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/RecoveryScanner.java (+20 lines)
39	scanner.isTaskCaseSensitive);	39	scanner.isTaskCaseSensitive);
40	setData(data);	40	setData(data);
41	}	41	}
		42
		43	public RecoveryScanner(
		44	boolean tokenizeWhiteSpace,
		45	boolean checkNonExternalizedStringLiterals,
		46	long sourceLevel,
		47	long complianceLevel,
		48	char[][] taskTags,
		49	char[][] taskPriorities,
		50	boolean isTaskCaseSensitive,
		51	RecoveryScannerData data) {
		52	super(false,
		53	tokenizeWhiteSpace,
		54	checkNonExternalizedStringLiterals,
		55	sourceLevel,
		56	complianceLevel,
		57	taskTags,
		58	taskPriorities,
		59	isTaskCaseSensitive);
		60	setData(data);
		61	}
42		62
43	public void insertToken(int token, int completedToken, int position) {	63	public void insertToken(int token, int completedToken, int position) {
44	insertTokens(new int []{token}, completedToken, position);	64	insertTokens(new int []{token}, completedToken, position);

Lines 14-22 Link Here

(-)dom/org/eclipse/jdt/internal/core/dom/rewrite/TokenScanner.java (-19 / +19 lines)
14	import org.eclipse.core.runtime.IStatus;	14	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.core.runtime.Status;	15	import org.eclipse.core.runtime.Status;
16	import org.eclipse.jdt.core.JavaCore;	16	import org.eclipse.jdt.core.JavaCore;
17	import org.eclipse.jdt.core.compiler.IScanner;
18	import org.eclipse.jdt.core.compiler.ITerminalSymbols;
19	import org.eclipse.jdt.core.compiler.InvalidInputException;	17	import org.eclipse.jdt.core.compiler.InvalidInputException;
		18	import org.eclipse.jdt.internal.compiler.parser.Scanner;
		19	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
20		20
21	/**	21	/**
22	* Wraps a scanner and offers convenient methods for finding tokens	22	* Wraps a scanner and offers convenient methods for finding tokens
Lines 27-40 Link Here
27	public static final int LEXICAL_ERROR= 20002;	27	public static final int LEXICAL_ERROR= 20002;
28	public static final int DOCUMENT_ERROR= 20003;	28	public static final int DOCUMENT_ERROR= 20003;
29		29
30	private final IScanner scanner;	30	private final Scanner scanner;
31	private final int endPosition;	31	private final int endPosition;
32		32
33	/**	33	/**
34	* Creates a TokenScanner	34	* Creates a TokenScanner
35	* @param scanner The scanner to be wrapped	35	* @param scanner The scanner to be wrapped
36	*/	36	*/
37	public TokenScanner(IScanner scanner) {	37	public TokenScanner(Scanner scanner) {
38	this.scanner= scanner;	38	this.scanner= scanner;
39	this.endPosition= this.scanner.getSource().length - 1;	39	this.endPosition= this.scanner.getSource().length - 1;
40	}	40	}
Lines 43-49 Link Here
43	* Returns the wrapped scanner	43	* Returns the wrapped scanner
44	* @return IScanner	44	* @return IScanner
45	*/	45	*/
46	public IScanner getScanner() {	46	public Scanner getScanner() {
47	return this.scanner;	47	return this.scanner;
48	}	48	}
49		49
Lines 88-94 Link Here
88	do {	88	do {
89	try {	89	try {
90	curr= this.scanner.getNextToken();	90	curr= this.scanner.getNextToken();
91	if (curr == ITerminalSymbols.TokenNameEOF) {	91	if (curr == TerminalTokens.TokenNameEOF) {
92	throw new CoreException(createError(END_OF_FILE, "End Of File", null)); //$NON-NLS-1$	92	throw new CoreException(createError(END_OF_FILE, "End Of File", null)); //$NON-NLS-1$
93	}	93	}
94	} catch (InvalidInputException e) {	94	} catch (InvalidInputException e) {
Lines 208-230 Link Here
208	}	208	}
209		209
210	public static boolean isComment(int token) {	210	public static boolean isComment(int token) {
211	return token == ITerminalSymbols.TokenNameCOMMENT_BLOCK \|\| token == ITerminalSymbols.TokenNameCOMMENT_JAVADOC	211	return token == TerminalTokens.TokenNameCOMMENT_BLOCK \|\| token == TerminalTokens.TokenNameCOMMENT_JAVADOC
212	\|\| token == ITerminalSymbols.TokenNameCOMMENT_LINE;	212	\|\| token == TerminalTokens.TokenNameCOMMENT_LINE;
213	}	213	}
214		214
215	public static boolean isModifier(int token) {	215	public static boolean isModifier(int token) {
216	switch (token) {	216	switch (token) {
217	case ITerminalSymbols.TokenNamepublic:	217	case TerminalTokens.TokenNamepublic:
218	case ITerminalSymbols.TokenNameprotected:	218	case TerminalTokens.TokenNameprotected:
219	case ITerminalSymbols.TokenNameprivate:	219	case TerminalTokens.TokenNameprivate:
220	case ITerminalSymbols.TokenNamestatic:	220	case TerminalTokens.TokenNamestatic:
221	case ITerminalSymbols.TokenNamefinal:	221	case TerminalTokens.TokenNamefinal:
222	case ITerminalSymbols.TokenNameabstract:	222	case TerminalTokens.TokenNameabstract:
223	case ITerminalSymbols.TokenNamenative:	223	case TerminalTokens.TokenNamenative:
224	case ITerminalSymbols.TokenNamevolatile:	224	case TerminalTokens.TokenNamevolatile:
225	case ITerminalSymbols.TokenNamestrictfp:	225	case TerminalTokens.TokenNamestrictfp:
226	case ITerminalSymbols.TokenNametransient:	226	case TerminalTokens.TokenNametransient:
227	case ITerminalSymbols.TokenNamesynchronized:	227	case TerminalTokens.TokenNamesynchronized:
228	return true;	228	return true;
229	default:	229	default:
230	return false;	230	return false;

Lines 26-31 Link Here

(-)dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java (-4 / +5 lines)
26	import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;	26	import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
27	import org.eclipse.jdt.core.dom.CompilationUnit;	27	import org.eclipse.jdt.core.dom.CompilationUnit;
28	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;	28	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
		29	import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
29	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer;	30	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteAnalyzer;
30	import org.eclipse.jdt.internal.core.dom.rewrite.LineInformation;	31	import org.eclipse.jdt.internal.core.dom.rewrite.LineInformation;
31	import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;	32	import org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore;
Lines 197-203 Link Here
197		198
198	ASTNode astRoot= rootNode.getRoot();	199	ASTNode astRoot= rootNode.getRoot();
199	List commentNodes= astRoot instanceof CompilationUnit ? ((CompilationUnit) astRoot).getCommentList() : null;	200	List commentNodes= astRoot instanceof CompilationUnit ? ((CompilationUnit) astRoot).getCommentList() : null;
200	return internalRewriteAST(content, lineInfo, lineDelim, commentNodes, options, rootNode);	201	return internalRewriteAST(content, lineInfo, lineDelim, commentNodes, options, rootNode, (RecoveryScannerData)((CompilationUnit) astRoot).getStatementsRecoveryData());
201	}	202	}
202		203
203	/**	204	/**
Lines 255-271 Link Here
255	String lineDelim= typeRoot.findRecommendedLineSeparator();	256	String lineDelim= typeRoot.findRecommendedLineSeparator();
256	Map options= typeRoot.getJavaProject().getOptions(true);	257	Map options= typeRoot.getJavaProject().getOptions(true);
257		258
258	return internalRewriteAST(content, lineInfo, lineDelim, astRoot.getCommentList(), options, rootNode);	259	return internalRewriteAST(content, lineInfo, lineDelim, astRoot.getCommentList(), options, rootNode, (RecoveryScannerData)astRoot.getStatementsRecoveryData());
259	}	260	}
260		261
261	private TextEdit internalRewriteAST(char[] content, LineInformation lineInfo, String lineDelim, List commentNodes, Map options, ASTNode rootNode) {	262	private TextEdit internalRewriteAST(char[] content, LineInformation lineInfo, String lineDelim, List commentNodes, Map options, ASTNode rootNode, RecoveryScannerData recoveryScannerData) {
262	TextEdit result= new MultiTextEdit();	263	TextEdit result= new MultiTextEdit();
263	//validateASTNotModified(rootNode);	264	//validateASTNotModified(rootNode);
264		265
265	TargetSourceRangeComputer sourceRangeComputer= getExtendedSourceRangeComputer();	266	TargetSourceRangeComputer sourceRangeComputer= getExtendedSourceRangeComputer();
266	this.eventStore.prepareMovedNodes(sourceRangeComputer);	267	this.eventStore.prepareMovedNodes(sourceRangeComputer);
267		268
268	ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, commentNodes, options, sourceRangeComputer);	269	ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, commentNodes, options, sourceRangeComputer, recoveryScannerData);
269	rootNode.accept(visitor); // throws IllegalArgumentException	270	rootNode.accept(visitor); // throws IllegalArgumentException
270		271
271	this.eventStore.revertMovedNodes();	272	this.eventStore.revertMovedNodes();

Added Link Here

(-)src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingWithStatementsRecoveryTest.java (+175 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.rewrite.describing;
12	import java.util.List;
13
14	import junit.framework.Test;
15	import junit.framework.TestSuite;
16
17	import org.eclipse.jdt.core.ICompilationUnit;
18	import org.eclipse.jdt.core.IPackageFragment;
19
20	import org.eclipse.jdt.core.dom.*;
21	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
22	import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
23
24	public class ASTRewritingWithStatementsRecoveryTest extends ASTRewritingTest {
25	private static final Class THIS= ASTRewritingWithStatementsRecoveryTest.class;
26
27	public ASTRewritingWithStatementsRecoveryTest(String name) {
28	super(name);
29	}
30
31	public static Test allTests() {
32	return new Suite(THIS);
33	}
34
35	public static Test setUpTest(Test someTest) {
36	TestSuite suite= new Suite("one test");
37	suite.addTest(someTest);
38	return suite;
39	}
40
41	public static Test suite() {
42	return allTests();
43	}
44
45	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
46	public void testBug272711_01() throws Exception {
47	IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
48	StringBuffer buf= new StringBuffer();
49	buf.append("package test1;\n");
50	buf.append("public class E {\n");
51	buf.append(" public void foo() {\n");
52	buf.append(" this.foo#3);\n");
53	buf.append(" }\n");
54	buf.append("}\n");
55	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
56
57	CompilationUnit astRoot= createAST3(cu, true);
58	AST ast= astRoot.getAST();
59	ASTRewrite rewrite= ASTRewrite.create(ast);
60
61	assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
62	TypeDeclaration type= findTypeDeclaration(astRoot, "E");
63	MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
64	Block block= methodDecl.getBody();
65	List statements= block.statements();
66	assertTrue("Number of statements not 1", statements.size() == 1);
67	{ // add type arguments
68	ExpressionStatement stmt= (ExpressionStatement) statements.get(0);
69	MethodInvocation invocation= (MethodInvocation) stmt.getExpression();
70	ASTNode firstArgument = (ASTNode) invocation.arguments().get(0);
71	NumberLiteral newNumberLiteral = ast.newNumberLiteral("0");
72	ListRewrite listRewriter= rewrite.getListRewrite(invocation, MethodInvocation.ARGUMENTS_PROPERTY);
73	listRewriter.replace(firstArgument, newNumberLiteral, null);
74	}
75	String preview= evaluateRewrite(cu, rewrite);
76
77	buf= new StringBuffer();
78	buf.append("package test1;\n");
79	buf.append("public class E {\n");
80	buf.append(" public void foo() {\n");
81	buf.append(" this.foo#0);\n");
82	buf.append(" }\n");
83	buf.append("}\n");
84	assertEqualString(preview, buf.toString());
85
86	}
87
88	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
89	public void testBug272711_02() throws Exception {
90	IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
91	StringBuffer buf= new StringBuffer();
92	buf.append("package test1;\n");
93	buf.append("public class E {\n");
94	buf.append(" public void foo() {\n");
95	buf.append(" throws new UnsupportedOperationException();\n");
96	buf.append(" }\n");
97	buf.append("}\n");
98	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
99
100	CompilationUnit astRoot= createAST3(cu, true);
101	AST ast= astRoot.getAST();
102	ASTRewrite rewrite= ASTRewrite.create(ast);
103
104	assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
105	TypeDeclaration type= findTypeDeclaration(astRoot, "E");
106	List bodyDeclarations = type.bodyDeclarations();
107	assertTrue("Number of body declarations not 1", bodyDeclarations.size() == 1);
108	{ // add field declaration
109	MethodDeclaration methodDeclaration = (MethodDeclaration)bodyDeclarations.get(0);
110	VariableDeclarationFragment newFragment = ast.newVariableDeclarationFragment();
111	newFragment.setName(ast.newSimpleName("field"));
112	FieldDeclaration newFieldDeclaration = ast.newFieldDeclaration(newFragment);
113	newFieldDeclaration.setType(ast.newSimpleType(ast.newName("Object")));
114	ListRewrite listRewriter= rewrite.getListRewrite(type, TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
115	listRewriter.insertBefore(newFieldDeclaration, methodDeclaration, null);
116	}
117	String preview= evaluateRewrite(cu, rewrite);
118
119	buf= new StringBuffer();
120	buf.append("package test1;\n");
121	buf.append("public class E {\n");
122	buf.append(" Object field;\n");
123	buf.append("\n");
124	buf.append(" public void foo() {\n");
125	buf.append(" throws new UnsupportedOperationException();\n");
126	buf.append(" }\n");
127	buf.append("}\n");
128	assertEqualString(preview, buf.toString());
129
130	}
131
132	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=272711
133	public void testBug272711_03() throws Exception {
134	IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
135	StringBuffer buf= new StringBuffer();
136	buf.append("package test1;\n");
137	buf.append("public class E {\n");
138	buf.append(" public void foo() {\n");
139	buf.append(" do {\n");
140	buf.append(" } (a);\n");
141	buf.append(" }\n");
142	buf.append("}\n");
143	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
144
145	CompilationUnit astRoot= createAST3(cu, true);
146	AST ast= astRoot.getAST();
147	ASTRewrite rewrite= ASTRewrite.create(ast);
148
149	assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
150	TypeDeclaration type= findTypeDeclaration(astRoot, "E");
151	MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
152	Block block= methodDecl.getBody();
153	List statements= block.statements();
154	assertTrue("Number of statements not 1", statements.size() == 1);
155	{ // replace the 'a' simple name with another simple name
156	DoStatement stmt= (DoStatement) statements.get(0);
157	Statement body = stmt.getBody();
158	EmptyStatement newEmptyStatement = ast.newEmptyStatement();
159	rewrite.replace(body, newEmptyStatement, null);
160	}
161	String preview= evaluateRewrite(cu, rewrite);
162
163	buf= new StringBuffer();
164	buf.append("package test1;\n");
165	buf.append("public class E {\n");
166	buf.append(" public void foo() {\n");
167	buf.append(" do\n");
168	buf.append(" ; (a);\n");
169	buf.append(" }\n");
170	buf.append("}\n");
171	assertEqualString(preview, buf.toString());
172
173	}
174
175	}