Attachment 133308 Details for Bug 272711 – Proposed patch

[patch] Proposed patch

bug272711_003.txt (text/plain), 51.25 KB, created by David Audel

on 2009-04-27 04:35:48 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: David Audel

Created: 2009-04-27 04:35:48 EDT

Size: 51.25 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: dom/org/eclipse/jdt/core/dom/ASTParser.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTParser.java,v
>retrieving revision 1.87
>diff -u -r1.87 ASTParser.java
>--- dom/org/eclipse/jdt/core/dom/ASTParser.java	31 Mar 2009 15:02:58 -0000	1.87
>+++ dom/org/eclipse/jdt/core/dom/ASTParser.java	27 Apr 2009 08:25:18 -0000
>@@ -1048,6 +1048,8 @@
> 					converter.scanner = new RecoveryScanner(scanner, data.removeUnused());
> 					converter.docParser.scanner = converter.scanner;
> 					converter.scanner.setSource(scanner.source);
>+					
>+					compilationUnit.setStatementsRecoveryData(data);
> 				}
> 				RecordedParsingInformation recordedParsingInformation = codeSnippetParsingUtil.recordedParsingInformation;
> 				int[][] comments = recordedParsingInformation.commentPositions;
>Index: dom/org/eclipse/jdt/core/dom/CompilationUnit.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java,v
>retrieving revision 1.90
>diff -u -r1.90 CompilationUnit.java
>--- dom/org/eclipse/jdt/core/dom/CompilationUnit.java	27 Jun 2008 16:03:46 -0000	1.90
>+++ dom/org/eclipse/jdt/core/dom/CompilationUnit.java	27 Apr 2009 08:25:18 -0000
>@@ -178,6 +178,11 @@
> 	 * Problems reported by the compiler during parsing or name resolution.
> 	 */
> 	private IProblem[] problems = EMPTY_PROBLEMS;
>+	
>+	/**
>+	 * Internal data used to perform statements recovery.
>+	 */
>+	private Object statementsRecoveryData;
> 
> 	/**
> 	 * The list of type declarations in textual order order;
>@@ -615,6 +620,20 @@
> 	}
> 
> 	/**
>+	 * Internal method
>+	 * 
>+	 * This method return internal data used to perform statements recovery.
>+	 * 
>+	 * @return internal data used to perform statements recovery.
>+	 * 
>+	 * @noreference This method is not intended to be referenced by clients.
>+	 * @since 3.5
>+	 */
>+	public Object getStatementsRecoveryData() {
>+		return this.statementsRecoveryData;
>+	}
>+	
>+	/**
> 	 * The Java type root (a {@link org.eclipse.jdt.core.ICompilationUnit compilation unit} or a {@link org.eclipse.jdt.core.IClassFile class file})
> 	 * this compilation unit was created from, or <code>null</code> if it was not created from a Java type root.
> 	 *
>@@ -1009,6 +1028,19 @@
> 		}
> 		this.problems = problems;
> 	}
>+	
>+	/**
>+	 * Internal method
>+	 * 
>+	 * Sets internal data used to perform statements recovery.
>+	 * @param data
>+	 * 
>+	 * @noreference This method is not intended to be referenced by clients.
>+	 * @since 3.5
>+	 */
>+	void setStatementsRecoveryData(Object data) {
>+		this.statementsRecoveryData = data;
>+	}
> 
> 	/* (omit javadoc for this method)
> 	 * Method declared on ASTNode.
>Index: dom/org/eclipse/jdt/core/dom/ASTConverter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java,v
>retrieving revision 1.268
>diff -u -r1.268 ASTConverter.java
>--- dom/org/eclipse/jdt/core/dom/ASTConverter.java	31 Mar 2009 15:06:38 -0000	1.268
>+++ dom/org/eclipse/jdt/core/dom/ASTConverter.java	27 Apr 2009 08:25:18 -0000
>@@ -1228,6 +1228,7 @@
> 		this.compilationUnitSourceLength = source.length;
> 		this.scanner.setSource(source, unit.compilationResult);
> 		CompilationUnit compilationUnit = new CompilationUnit(this.ast);
>+		compilationUnit.setStatementsRecoveryData(unit.compilationResult.recoveryScannerData);
> 
> 		// Parse comments
> 		int[][] comments = unit.comments;
>Index: dom/org/eclipse/jdt/core/dom/InternalASTRewrite.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/InternalASTRewrite.java,v
>retrieving revision 1.13
>diff -u -r1.13 InternalASTRewrite.java
>--- dom/org/eclipse/jdt/core/dom/InternalASTRewrite.java	7 Mar 2009 01:08:09 -0000	1.13
>+++ dom/org/eclipse/jdt/core/dom/InternalASTRewrite.java	27 Apr 2009 08:25:18 -0000
>@@ -22,6 +22,7 @@
> import org.eclipse.jdt.core.dom.SimplePropertyDescriptor;
> import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
> import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
>+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.ListRewriteEvent;
>@@ -89,7 +90,7 @@
> 			String lineDelim= TextUtilities.getDefaultLineDelimiter(document);
> 			List comments= rootNode.getCommentList();
> 
>-			ASTRewriteAnalyzer visitor = new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, comments, options, xsrComputer);
>+			ASTRewriteAnalyzer visitor = new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, comments, options, xsrComputer, (RecoveryScannerData)rootNode.getStatementsRecoveryData());
> 			rootNode.accept(visitor);
> 		}
> 		return result;
>Index: compiler/org/eclipse/jdt/internal/compiler/parser/RecoveryScanner.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/RecoveryScanner.java,v
>retrieving revision 1.11
>diff -u -r1.11 RecoveryScanner.java
>--- compiler/org/eclipse/jdt/internal/compiler/parser/RecoveryScanner.java	7 Mar 2009 01:08:07 -0000	1.11
>+++ compiler/org/eclipse/jdt/internal/compiler/parser/RecoveryScanner.java	27 Apr 2009 08:25:17 -0000
>@@ -39,6 +39,26 @@
> 				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);
>Index: dom/org/eclipse/jdt/internal/core/dom/rewrite/TokenScanner.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/TokenScanner.java,v
>retrieving revision 1.11
>diff -u -r1.11 TokenScanner.java
>--- dom/org/eclipse/jdt/internal/core/dom/rewrite/TokenScanner.java	7 Mar 2009 01:08:10 -0000	1.11
>+++ dom/org/eclipse/jdt/internal/core/dom/rewrite/TokenScanner.java	27 Apr 2009 08:25:19 -0000
>@@ -14,9 +14,9 @@
> 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
>@@ -27,14 +27,14 @@
> 	public static final int LEXICAL_ERROR= 20002;
> 	public static final int DOCUMENT_ERROR= 20003;
> 
>-	private final IScanner scanner;
>+	private final Scanner scanner;
> 	private final int endPosition;
> 
> 	/**
> 	 * Creates a TokenScanner
> 	 * @param scanner The scanner to be wrapped
> 	 */
>-	public TokenScanner(IScanner scanner) {
>+	public TokenScanner(Scanner scanner) {
> 		this.scanner= scanner;
> 		this.endPosition= this.scanner.getSource().length - 1;
> 	}
>@@ -43,7 +43,7 @@
> 	 * Returns the wrapped scanner
> 	 * @return IScanner
> 	 */
>-	public IScanner getScanner() {
>+	public Scanner getScanner() {
> 		return this.scanner;
> 	}
> 
>@@ -88,7 +88,7 @@
> 		do {
> 			try {
> 				curr= this.scanner.getNextToken();
>-				if (curr == ITerminalSymbols.TokenNameEOF) {
>+				if (curr == TerminalTokens.TokenNameEOF) {
> 					throw new CoreException(createError(END_OF_FILE, "End Of File", null)); //$NON-NLS-1$
> 				}
> 			} catch (InvalidInputException e) {
>@@ -208,23 +208,23 @@
> 	}
> 
> 	public static boolean isComment(int token) {
>-		return token == ITerminalSymbols.TokenNameCOMMENT_BLOCK || token == ITerminalSymbols.TokenNameCOMMENT_JAVADOC
>-			|| token == ITerminalSymbols.TokenNameCOMMENT_LINE;
>+		return token == TerminalTokens.TokenNameCOMMENT_BLOCK || token == TerminalTokens.TokenNameCOMMENT_JAVADOC
>+			|| token == TerminalTokens.TokenNameCOMMENT_LINE;
> 	}
> 
> 	public static boolean isModifier(int token) {
> 		switch (token) {
>-			case ITerminalSymbols.TokenNamepublic:
>-			case ITerminalSymbols.TokenNameprotected:
>-			case ITerminalSymbols.TokenNameprivate:
>-			case ITerminalSymbols.TokenNamestatic:
>-			case ITerminalSymbols.TokenNamefinal:
>-			case ITerminalSymbols.TokenNameabstract:
>-			case ITerminalSymbols.TokenNamenative:
>-			case ITerminalSymbols.TokenNamevolatile:
>-			case ITerminalSymbols.TokenNamestrictfp:
>-			case ITerminalSymbols.TokenNametransient:
>-			case ITerminalSymbols.TokenNamesynchronized:
>+			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;
>Index: dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java,v
>retrieving revision 1.61
>diff -u -r1.61 ASTRewriteAnalyzer.java
>--- dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	7 Mar 2009 00:59:06 -0000	1.61
>+++ dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	27 Apr 2009 08:25:19 -0000
>@@ -19,15 +19,17 @@
> 
> import org.eclipse.core.runtime.Assert;
> import org.eclipse.core.runtime.CoreException;
>-import org.eclipse.jdt.core.ToolFactory;
>-import org.eclipse.jdt.core.compiler.IScanner;
>-import org.eclipse.jdt.core.compiler.ITerminalSymbols;
> import org.eclipse.jdt.core.dom.*;
> import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
> import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;
> import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
> import org.eclipse.jdt.core.formatter.IndentManipulation;
>+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
>+import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;
>+import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
>+import org.eclipse.jdt.internal.compiler.parser.Scanner;
> import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
>+import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
> import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;
> import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.NodeMarker;
> import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.Prefix;
>@@ -82,6 +84,8 @@
> 	private int beforeRequiredSpaceIndex = -1;
> 	
> 	Map options;
>+	
>+	private RecoveryScannerData recoveryScannerData;
> 
> 	/**
> 	 * Constructor for ASTRewriteAnalyzer.
>@@ -91,10 +95,21 @@
> 	 * @param eventStore the event store containing the description of changes
> 	 * @param nodeInfos annotations to nodes, such as if a node is a string placeholder or a copy target
> 	 * @param comments list of comments of the compilation unit to rewrite (elements of type <code>Comment</code>) or <code>null</code>.
>-	 * 	@param options the current jdt.core options (formatting/compliance) or <code>null</code>.
>-	 * 	@param extendedSourceRangeComputer the source range computer to use
>-	 */
>-	public ASTRewriteAnalyzer(char[] content, LineInformation lineInfo, String lineDelim, TextEdit rootEdit, RewriteEventStore eventStore, NodeInfoStore nodeInfos, List comments, Map options, TargetSourceRangeComputer extendedSourceRangeComputer) {
>+	 * @param options the current jdt.core options (formatting/compliance) or <code>null</code>.
>+	 * @param extendedSourceRangeComputer the source range computer to use
>+	 * @param recoveryScannerData internal data used by {@link RecoveryScanner}
>+	 */
>+	public ASTRewriteAnalyzer(
>+			char[] content,
>+			LineInformation lineInfo,
>+			String lineDelim,
>+			TextEdit rootEdit,
>+			RewriteEventStore eventStore,
>+			NodeInfoStore nodeInfos,
>+			List comments,
>+			Map options,
>+			TargetSourceRangeComputer extendedSourceRangeComputer,
>+			RecoveryScannerData recoveryScannerData) {
> 		this.eventStore= eventStore;
> 		this.content= content;
> 		this.lineInfo= lineInfo;
>@@ -110,11 +125,37 @@
> 		this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
> 		
> 		this.options = options;
>+		
>+		this.recoveryScannerData = recoveryScannerData;
> 	}
> 
> 	final TokenScanner getScanner() {
> 		if (this.tokenScanner == null) {
>-			IScanner scanner= ToolFactory.createScanner(true, false, false, false);
>+			CompilerOptions compilerOptions = new CompilerOptions(this.options);
>+			Scanner scanner;
>+			if (this.recoveryScannerData == null) {
>+				scanner = 
>+					new Scanner(
>+							true,/*tokenizeComments*/
>+							false,/*tokenizeWhiteSpace*/
>+							false,/*checkNonExternalizedStringLiterals*/
>+							compilerOptions.sourceLevel,
>+							compilerOptions.complianceLevel,
>+							null/*taskTags*/,
>+							null/*taskPriorities*/,
>+							true/*taskCaseSensitive*/);
>+			} else {
>+				scanner =
>+					new RecoveryScanner(
>+							false,/*tokenizeWhiteSpace*/
>+							false,/*checkNonExternalizedStringLiterals*/
>+							compilerOptions.sourceLevel,
>+							compilerOptions.complianceLevel,
>+							null/*taskTags*/,
>+							null/*taskPriorities*/,
>+							true/*taskCaseSensitive*/,
>+							this.recoveryScannerData);
>+			}
> 			scanner.setSource(this.content);
> 			this.tokenScanner= new TokenScanner(scanner);
> 		}
>@@ -759,7 +800,7 @@
> 					try {
> 						ASTNode node= (ASTNode) event.getOriginalValue();
> 						TextEditGroup editGroup= getEditGroup(event);
>-						int dotEnd= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, node.getStartPosition() + node.getLength());
>+						int dotEnd= getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, node.getStartPosition() + node.getLength());
> 						doTextRemoveAndVisit(startPos, dotEnd - startPos, node, editGroup);
> 						return dotEnd;
> 					} catch (CoreException e) {
>@@ -777,7 +818,7 @@
> 					doTextRemoveAndVisit(offset, length, node, editGroup);
> 					doTextInsert(offset, (ASTNode) event.getNewValue(), getIndent(startPos), true, editGroup);
> 					try {
>-						return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, offset + length);
>+						return getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, offset + length);
> 					} catch (CoreException e) {
> 						handleException(e);
> 					}
>@@ -791,7 +832,7 @@
> 		}
> 		int pos= doVisit((ASTNode) node);
> 		try {
>-			return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, pos);
>+			return getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, pos);
> 		} catch (CoreException e) {
> 			handleException(e);
> 		}
>@@ -923,7 +964,7 @@
> 				}
> 				boolean isAllRemoved= !isAllInserted && isAllOfKind(children, RewriteEvent.REMOVED);
> 				if (isAllRemoved) { // all removed: set start to left bracket
>-					int posBeforeOpenBracket= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameLESS, pos);
>+					int posBeforeOpenBracket= getScanner().getTokenStartOffset(TerminalTokens.TokenNameLESS, pos);
> 					if (posBeforeOpenBracket != pos) {
> 						needsSpaceOnRemoveAll= false;
> 					}
>@@ -931,7 +972,7 @@
> 				}
> 				pos= new ListRewriter().rewriteList(parent, property, pos, String.valueOf('<'), ", "); //$NON-NLS-1$
> 				if (isAllRemoved) { // all removed: remove right and space up to next element
>-					int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameGREATER, pos); // set pos to '>'
>+					int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameGREATER, pos); // set pos to '>'
> 					endPos= getScanner().getNextStartOffset(endPos, false);
> 					String replacement= needsSpaceOnRemoveAll ? String.valueOf(' ') : new String();
> 					doTextReplace(pos, endPos - pos, replacement, getEditGroup(children[children.length - 1]));
>@@ -948,7 +989,7 @@
> 		}
> 		if (pos != offset) { // list contained some type -> parse after closing bracket
> 			try {
>-				return getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameGREATER, pos);
>+				return getScanner().getTokenEndOffset(TerminalTokens.TokenNameGREATER, pos);
> 			} catch (CoreException e) {
> 				handleException(e);
> 			}
>@@ -1033,7 +1074,7 @@
> 			try {
> 				getScanner().setOffset(pos);
> 				for (int i= newDim; i < oldDim; i++) {
>-					getScanner().readToToken(ITerminalSymbols.TokenNameRBRACKET);
>+					getScanner().readToToken(TerminalTokens.TokenNameRBRACKET);
> 				}
> 				doTextRemove(pos, getScanner().getCurrentEndOffset() - pos, editGroup);
> 			} catch (CoreException e) {
>@@ -1048,7 +1089,7 @@
> 	private int getPosAfterLeftBrace(int pos) {
> 		try {
> 			int nextToken= getScanner().readNext(pos, true);
>-			if (nextToken == ITerminalSymbols.TokenNameLBRACE) {
>+			if (nextToken == TerminalTokens.TokenNameLBRACE) {
> 				return getScanner().getCurrentEndOffset();
> 			}
> 		} catch (CoreException e) {
>@@ -1164,17 +1205,17 @@
> 				}
> 				boolean keep= true;
> 				switch (tok) {
>-					case ITerminalSymbols.TokenNamepublic: keep= Modifier.isPublic(newModifiers); break;
>-					case ITerminalSymbols.TokenNameprotected: keep= Modifier.isProtected(newModifiers); break;
>-					case ITerminalSymbols.TokenNameprivate: keep= Modifier.isPrivate(newModifiers); break;
>-					case ITerminalSymbols.TokenNamestatic: keep= Modifier.isStatic(newModifiers); break;
>-					case ITerminalSymbols.TokenNamefinal: keep= Modifier.isFinal(newModifiers); break;
>-					case ITerminalSymbols.TokenNameabstract: keep= Modifier.isAbstract(newModifiers); break;
>-					case ITerminalSymbols.TokenNamenative: keep= Modifier.isNative(newModifiers); break;
>-					case ITerminalSymbols.TokenNamevolatile: keep= Modifier.isVolatile(newModifiers); break;
>-					case ITerminalSymbols.TokenNamestrictfp: keep= Modifier.isStrictfp(newModifiers); break;
>-					case ITerminalSymbols.TokenNametransient: keep= Modifier.isTransient(newModifiers); break;
>-					case ITerminalSymbols.TokenNamesynchronized: keep= Modifier.isSynchronized(newModifiers); break;
>+					case TerminalTokens.TokenNamepublic: keep= Modifier.isPublic(newModifiers); break;
>+					case TerminalTokens.TokenNameprotected: keep= Modifier.isProtected(newModifiers); break;
>+					case TerminalTokens.TokenNameprivate: keep= Modifier.isPrivate(newModifiers); break;
>+					case TerminalTokens.TokenNamestatic: keep= Modifier.isStatic(newModifiers); break;
>+					case TerminalTokens.TokenNamefinal: keep= Modifier.isFinal(newModifiers); break;
>+					case TerminalTokens.TokenNameabstract: keep= Modifier.isAbstract(newModifiers); break;
>+					case TerminalTokens.TokenNamenative: keep= Modifier.isNative(newModifiers); break;
>+					case TerminalTokens.TokenNamevolatile: keep= Modifier.isVolatile(newModifiers); break;
>+					case TerminalTokens.TokenNamestrictfp: keep= Modifier.isStrictfp(newModifiers); break;
>+					case TerminalTokens.TokenNametransient: keep= Modifier.isTransient(newModifiers); break;
>+					case TerminalTokens.TokenNamesynchronized: keep= Modifier.isSynchronized(newModifiers); break;
> 					default:
> 						break loop;
> 				}
>@@ -1395,7 +1436,7 @@
> 		boolean invertType= isChanged(node, TypeDeclaration.INTERFACE_PROPERTY);
> 		if (invertType) {
> 			try {
>-				int typeToken= isInterface ? ITerminalSymbols.TokenNameinterface : ITerminalSymbols.TokenNameclass;
>+				int typeToken= isInterface ? TerminalTokens.TokenNameinterface : TerminalTokens.TokenNameclass;
> 				getScanner().readToToken(typeToken, node.getStartPosition());
> 
> 				String str= isInterface ? "class" : "interface"; //$NON-NLS-1$ //$NON-NLS-2$
>@@ -1544,13 +1585,13 @@
> 		// parameters
> 		try {
> 			if (isChanged(node, MethodDeclaration.PARAMETERS_PROPERTY)) {
>-				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				pos= rewriteNodeList(node, MethodDeclaration.PARAMETERS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} else {
> 				pos= doVisit(node, MethodDeclaration.PARAMETERS_PROPERTY, pos);
> 			}
> 
>-			pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);
>+			pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
> 
> 			int extraDims= rewriteExtraDimensions(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY, pos);
> 
>@@ -1561,7 +1602,7 @@
> 			if ((extraDims > 0) && (hasExceptionChanges || bodyChangeKind == RewriteEvent.INSERTED || bodyChangeKind == RewriteEvent.REMOVED)) {
> 				int dim= ((Integer) getOriginalValue(node, MethodDeclaration.EXTRA_DIMENSIONS_PROPERTY)).intValue();
> 				while (dim > 0) {
>-					pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, pos);
>+					pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, pos);
> 					dim--;
> 				}
> 			}
>@@ -1598,7 +1639,7 @@
> 	 */
> 	public boolean visit(ReturnStatement node) {
> 		try {
>-			this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamereturn, node.getStartPosition());
>+			this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(TerminalTokens.TokenNamereturn, node.getStartPosition());
> 			
> 			if (!hasChildrenChanges(node)) {
> 				return doVisitUnchangedChildren(node);
>@@ -1673,7 +1714,7 @@
> 
> 
> 		try {
>-			int offset= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameLBRACKET, arrayType.getStartPosition());
>+			int offset= getScanner().getTokenStartOffset(TerminalTokens.TokenNameLBRACKET, arrayType.getStartPosition());
> 			// dimension node with expressions
> 			RewriteEvent dimEvent= getEvent(node, ArrayCreation.DIMENSIONS_PROPERTY);
> 			boolean hasDimensionChanges= (dimEvent != null && dimEvent.getChangeKind() != RewriteEvent.UNCHANGED);
>@@ -1692,7 +1733,7 @@
> 					} else {
> 						ASTNode elem= (ASTNode) event.getOriginalValue();
> 						int elemEnd= elem.getStartPosition() + elem.getLength();
>-						int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, elemEnd);
>+						int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, elemEnd);
> 						if (changeKind == RewriteEvent.REMOVED) {
> 							editGroup= getEditGroup(event);
> 							doTextRemoveAndVisit(offset, endPos - offset, elem, editGroup);
>@@ -1717,14 +1758,14 @@
> 			}
> 			if (nOldBrackets != nNewBrackets) {
> 				if (!hasDimensionChanges) {
>-					offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRBRACKET, offset);
>+					offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRBRACKET, offset);
> 				}
> 				rewriteExtraDimensions(nOldBrackets, nNewBrackets, offset, editGroup);
> 			}
> 
> 			int kind= getChangeKind(node, ArrayCreation.INITIALIZER_PROPERTY);
> 			if (kind == RewriteEvent.REMOVED) {
>-				offset= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, offset);
>+				offset= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, offset);
> 			} else {
> 				offset= node.getStartPosition() + node.getLength(); // insert pos
> 			}
>@@ -1838,7 +1879,7 @@
> 		}
> 
> 		try {
>-			int offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamebreak, node.getStartPosition());
>+			int offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamebreak, node.getStartPosition());
> 			rewriteNode(node, BreakStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between break and label
> 		} catch (CoreException e) {
> 			handleException(e);
>@@ -1900,7 +1941,7 @@
> 		} else {
> 			if (isChanged(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY)) {
> 				try {
>-					pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamenew, pos); //after 'new'
>+					pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNamenew, pos); //after 'new'
> 					rewriteOptionalTypeParameters(node, ClassInstanceCreation.TYPE_ARGUMENTS_PROPERTY, pos, " ", true, true); //$NON-NLS-1$
> 				} catch (CoreException e) {
> 					handleException(e);
>@@ -1913,7 +1954,7 @@
> 
> 		if (isChanged(node, ClassInstanceCreation.ARGUMENTS_PROPERTY)) {
> 			try {
>-				int startpos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				int startpos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, ClassInstanceCreation.ARGUMENTS_PROPERTY, startpos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -1925,7 +1966,7 @@
> 		int kind= getChangeKind(node, ClassInstanceCreation.ANONYMOUS_CLASS_DECLARATION_PROPERTY);
> 		if (kind == RewriteEvent.REMOVED) {
> 			try {
>-				pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
>+				pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
> 			} catch (CoreException e) {
> 				handleException(e);
> 			}
>@@ -1962,7 +2003,7 @@
> 			pos= rewriteOptionalTypeParameters(node, ConstructorInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$
> 		}
> 		try {
>-			pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+			pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 			rewriteNodeList(node, ConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 		} catch (CoreException e) {
> 			handleException(e);
>@@ -1979,7 +2020,7 @@
> 		}
> 
> 		try {
>-			int offset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamecontinue, node.getStartPosition());
>+			int offset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamecontinue, node.getStartPosition());
> 			rewriteNode(node, ContinueStatement.LABEL_PROPERTY, offset, ASTRewriteFormatter.SPACE); // space between continue and label
> 		} catch (CoreException e) {
> 			handleException(e);
>@@ -1999,10 +2040,10 @@
> 		try {
> 			RewriteEvent event= getEvent(node, DoStatement.BODY_PROPERTY);
> 			if (event != null && event.getChangeKind() == RewriteEvent.REPLACED) {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamedo, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNamedo, pos);
> 				ASTNode body= (ASTNode) event.getOriginalValue();
> 				int bodyEnd= body.getStartPosition() + body.getLength();
>-				int endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNamewhile, bodyEnd);
>+				int endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNamewhile, bodyEnd);
> 				rewriteBodyNode(node, DoStatement.BODY_PROPERTY, startOffset, endPos, getIndent(node.getStartPosition()), this.formatter.DO_BLOCK); // body
> 			} else {
> 				voidVisit(node, DoStatement.BODY_PROPERTY);
>@@ -2085,19 +2126,19 @@
> 
> 			if (isChanged(node, ForStatement.INITIALIZERS_PROPERTY)) {
> 				// position after opening parent
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				pos= rewriteNodeList(node, ForStatement.INITIALIZERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} else {
> 				pos= doVisit(node, ForStatement.INITIALIZERS_PROPERTY, pos);
> 			}
> 
> 			// position after first semicolon
>-			pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);
>+			pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameSEMICOLON, pos);
> 
> 			pos= rewriteNode(node, ForStatement.EXPRESSION_PROPERTY, pos, ASTRewriteFormatter.NONE);
> 
> 			if (isChanged(node, ForStatement.UPDATERS_PROPERTY)) {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameSEMICOLON, pos);
> 				pos= rewriteNodeList(node, ForStatement.UPDATERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} else {
> 				pos= doVisit(node, ForStatement.UPDATERS_PROPERTY, pos);
>@@ -2105,7 +2146,7 @@
> 
> 			RewriteEvent bodyEvent= getEvent(node, ForStatement.BODY_PROPERTY);
> 			if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
> 				rewriteBodyNode(node, ForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body
> 			} else {
> 				voidVisit(node, ForStatement.BODY_PROPERTY);
>@@ -2135,7 +2176,7 @@
> 		if (thenEvent != null && thenEvent.getChangeKind() != RewriteEvent.UNCHANGED) {
> 			try {
> 				int tok= getScanner().readNext(pos, true); // after the closing parent
>-				pos= (tok == ITerminalSymbols.TokenNameRPAREN) ? getScanner().getCurrentEndOffset() : getScanner().getCurrentStartOffset();
>+				pos= (tok == TerminalTokens.TokenNameRPAREN) ? getScanner().getCurrentEndOffset() : getScanner().getCurrentStartOffset();
> 				
> 				int indent= getIndent(node.getStartPosition());
> 
>@@ -2143,7 +2184,7 @@
> 				Object elseStatement= getOriginalValue(node, IfStatement.ELSE_STATEMENT_PROPERTY);
> 				if (elseStatement != null) {
> 					ASTNode thenStatement = (ASTNode) thenEvent.getOriginalValue();
>-					endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameelse, thenStatement.getStartPosition() + thenStatement.getLength()); // else keyword
>+					endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNameelse, thenStatement.getStartPosition() + thenStatement.getLength()); // else keyword
> 				}
> 				if (elseStatement == null || elseChange != RewriteEvent.UNCHANGED) {
> 					pos= rewriteBodyNode(node, IfStatement.THEN_STATEMENT_PROPERTY, pos, endPos, indent, this.formatter.IF_BLOCK_NO_ELSE);
>@@ -2182,10 +2223,10 @@
> 			RewriteEvent event= getEvent(node, ImportDeclaration.STATIC_PROPERTY);
> 			if (event != null && event.getChangeKind() != RewriteEvent.UNCHANGED) {
> 				try {
>-					int pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameimport, node.getStartPosition());
>+					int pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameimport, node.getStartPosition());
> 					boolean wasStatic= ((Boolean) event.getOriginalValue()).booleanValue();
> 					if (wasStatic) {
>-						int endPos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamestatic, pos);
>+						int endPos= getScanner().getTokenEndOffset(TerminalTokens.TokenNamestatic, pos);
> 						doTextRemove(pos, endPos - pos, getEditGroup(event));
> 					} else {
> 						doTextInsert(pos, " static", getEditGroup(event)); //$NON-NLS-1$
>@@ -2205,7 +2246,7 @@
> 				doTextInsert(pos, ".*", getEditGroup(event)); //$NON-NLS-1$
> 			} else {
> 				try {
>-					int endPos= getScanner().getTokenStartOffset(ITerminalSymbols.TokenNameSEMICOLON, pos);
>+					int endPos= getScanner().getTokenStartOffset(TerminalTokens.TokenNameSEMICOLON, pos);
> 					doTextRemove(pos, endPos - pos, getEditGroup(event));
> 				} catch (CoreException e) {
> 					handleException(e);
>@@ -2380,7 +2421,7 @@
> 		if (isChanged(node, MethodInvocation.ARGUMENTS_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, MethodInvocation.ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -2557,7 +2598,7 @@
> 			int kind= getChangeKind(node, SingleVariableDeclaration.INITIALIZER_PROPERTY);
> 			if (kind == RewriteEvent.REMOVED) {
> 				try {
>-					pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameEQUAL, pos);
>+					pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameEQUAL, pos);
> 				} catch (CoreException e) {
> 					handleException(e);
> 				}
>@@ -2601,7 +2642,7 @@
> 		if (isChanged(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, SuperConstructorInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -2638,7 +2679,7 @@
> 		if (node.getAST().apiLevel() >= AST.JLS3) {
> 			if (isChanged(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY)) {
> 				try {
>-					pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameDOT, pos);
>+					pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameDOT, pos);
> 					rewriteOptionalTypeParameters(node, SuperMethodInvocation.TYPE_ARGUMENTS_PROPERTY, pos, "", false, false); //$NON-NLS-1$
> 				} catch (CoreException e) {
> 					handleException(e);
>@@ -2651,7 +2692,7 @@
> 		if (isChanged(node, SuperMethodInvocation.ARGUMENTS_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, SuperMethodInvocation.ARGUMENTS_PROPERTY, pos, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -2756,7 +2797,7 @@
> 		ChildListPropertyDescriptor property= SwitchStatement.STATEMENTS_PROPERTY;
> 		if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {
> 			try {
>-				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
>+				pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
> 				int insertIndent= getIndent(node.getStartPosition());
> 				if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {
> 					insertIndent++;
>@@ -2806,7 +2847,7 @@
> 	 */
> 	public boolean visit(ThrowStatement node) {
> 		try {
>-			this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(ITerminalSymbols.TokenNamethrow, node.getStartPosition());
>+			this.beforeRequiredSpaceIndex = getScanner().getTokenEndOffset(TerminalTokens.TokenNamethrow, node.getStartPosition());
> 			
> 			if (!hasChildrenChanges(node)) {
> 				return doVisitUnchangedChildren(node);
>@@ -2907,7 +2948,7 @@
> 			int kind= getChangeKind(node, VariableDeclarationFragment.INITIALIZER_PROPERTY);
> 			if (kind == RewriteEvent.REMOVED) {
> 				try {
>-					pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameEQUAL, pos);
>+					pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameEQUAL, pos);
> 				} catch (CoreException e) {
> 					handleException(e);
> 				}
>@@ -2952,7 +2993,7 @@
> 
> 		try {
> 			if (isChanged(node, WhileStatement.BODY_PROPERTY)) {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
> 				rewriteBodyNode(node, WhileStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.WHILE_BLOCK); // body
> 			} else {
> 				voidVisit(node, WhileStatement.BODY_PROPERTY);
>@@ -2990,7 +3031,7 @@
> 		if (isChanged(node, MethodRef.PARAMETERS_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, MethodRef.PARAMETERS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -3123,7 +3164,7 @@
> 		try {
> 			int changeKind= getChangeKind(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY);
> 			if (changeKind == RewriteEvent.INSERTED || changeKind == RewriteEvent.REMOVED) {
>-				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);
>+				pos= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
> 			}
> 			rewriteNode(node, AnnotationTypeMemberDeclaration.DEFAULT_PROPERTY, pos, this.formatter.ANNOT_MEMBER_DEFAULT);
> 		} catch (CoreException e) {
>@@ -3146,7 +3187,7 @@
> 		if (bodyEvent != null && bodyEvent.getChangeKind() == RewriteEvent.REPLACED) {
> 			int startOffset;
> 			try {
>-				startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameRPAREN, pos);
>+				startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameRPAREN, pos);
> 				rewriteBodyNode(node, EnhancedForStatement.BODY_PROPERTY, startOffset, -1, getIndent(node.getStartPosition()), this.formatter.FOR_BLOCK); // body
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -3172,7 +3213,7 @@
> 			RewriteEvent[] children= argsEvent.getChildren();
> 			try {
> 				int nextTok= getScanner().readNext(pos, true);
>-				boolean hasParents= (nextTok == ITerminalSymbols.TokenNameLPAREN);
>+				boolean hasParents= (nextTok == TerminalTokens.TokenNameLPAREN);
> 				boolean isAllRemoved= hasParents && isAllOfKind(children, RewriteEvent.REMOVED);
> 				String prefix= ""; //$NON-NLS-1$
> 				if (!hasParents) {
>@@ -3201,7 +3242,7 @@
> 			if (kind == RewriteEvent.REMOVED) {
> 				try {
> 					// 'pos' can be before brace
>-					pos= getScanner().getPreviousTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
>+					pos= getScanner().getPreviousTokenEndOffset(TerminalTokens.TokenNameLBRACE, pos);
> 				} catch (CoreException e) {
> 					handleException(e);
> 				}
>@@ -3250,7 +3291,7 @@
> 					indent= getIndent(node.getStartPosition()) + 1;
> 				}
> 				int token= getScanner().readNext(pos, true);
>-				boolean hasSemicolon= token == ITerminalSymbols.TokenNameSEMICOLON;
>+				boolean hasSemicolon= token == TerminalTokens.TokenNameSEMICOLON;
> 				if (!hasSemicolon && isAllOfKind(children, RewriteEvent.INSERTED)) {
> 					if (!hasConstants) {
> 						String str= this.formatter.FIRST_ENUM_CONST.getPrefix(indent - 1);
>@@ -3316,7 +3357,7 @@
> 		if (isChanged(node, NormalAnnotation.VALUES_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLPAREN, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLPAREN, pos);
> 				rewriteNodeList(node, NormalAnnotation.VALUES_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>@@ -3337,7 +3378,7 @@
> 		if (isChanged(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY)) {
> 			// eval position after opening parent
> 			try {
>-				int startOffset= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLESS, pos);
>+				int startOffset= getScanner().getTokenEndOffset(TerminalTokens.TokenNameLESS, pos);
> 				rewriteNodeList(node, ParameterizedType.TYPE_ARGUMENTS_PROPERTY, startOffset, "", ", "); //$NON-NLS-1$ //$NON-NLS-2$
> 			} catch (CoreException e) {
> 				handleException(e);
>Index: dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java,v
>retrieving revision 1.39
>diff -u -r1.39 ASTRewrite.java
>--- dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java	11 Aug 2008 18:09:36 -0000	1.39
>+++ dom/org/eclipse/jdt/core/dom/rewrite/ASTRewrite.java	27 Apr 2009 08:25:18 -0000
>@@ -26,6 +26,7 @@
> 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;
>@@ -197,7 +198,7 @@
> 
> 		ASTNode astRoot= rootNode.getRoot();
> 		List commentNodes= astRoot instanceof CompilationUnit ? ((CompilationUnit) astRoot).getCommentList() : null;
>-		return internalRewriteAST(content, lineInfo, lineDelim, commentNodes, options, rootNode);
>+		return internalRewriteAST(content, lineInfo, lineDelim, commentNodes, options, rootNode, (RecoveryScannerData)((CompilationUnit) astRoot).getStatementsRecoveryData());
> 	}
> 
> 	/**
>@@ -255,17 +256,17 @@
> 		String lineDelim= typeRoot.findRecommendedLineSeparator();
> 		Map options= typeRoot.getJavaProject().getOptions(true);
> 
>-		return internalRewriteAST(content, lineInfo, lineDelim, astRoot.getCommentList(), options, rootNode);
>+		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) {
>+	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);
>+		ASTRewriteAnalyzer visitor= new ASTRewriteAnalyzer(content, lineInfo, lineDelim, result, this.eventStore, this.nodeStore, commentNodes, options, sourceRangeComputer, recoveryScannerData);
> 		rootNode.accept(visitor); // throws IllegalArgumentException
> 
> 		this.eventStore.revertMovedNodes();
>#P org.eclipse.jdt.core.tests.model
>Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java,v
>retrieving revision 1.23
>diff -u -r1.23 ASTRewritingTest.java
>--- src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	4 Feb 2009 13:55:18 -0000	1.23
>+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	27 Apr 2009 08:25:21 -0000
>@@ -49,6 +49,7 @@
> 		suite.addTest(SourceModifierTest.allTests());
> 		suite.addTest(ImportRewriteTest.allTests());
> 		suite.addTest(LineCommentOffsetsTest.allTests());
>+		suite.addTest(ASTRewritingWithStatementsRecoveryTest.allTests());
> 		return suite;
> 	}
> 
>@@ -97,9 +98,14 @@
> 	}
> 
> 	protected CompilationUnit createAST3(ICompilationUnit cu) {
>+		return createAST3(cu, false);
>+	}
>+	
>+	protected CompilationUnit createAST3(ICompilationUnit cu, boolean statementsRecovery) {
> 		ASTParser parser= ASTParser.newParser(AST.JLS3);
> 		parser.setSource(cu);
> 		parser.setResolveBindings(false);
>+		parser.setStatementsRecovery(statementsRecovery);
> 		return (CompilationUnit) parser.createAST(null);
> 	}
> 
>Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingWithStatementsRecoveryTest.java
>===================================================================
>RCS file: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingWithStatementsRecoveryTest.java
>diff -N src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingWithStatementsRecoveryTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingWithStatementsRecoveryTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,175 @@
>+/*******************************************************************************
>+ * 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());
>+
>+	}
>+
>+}

Actions: View | Diff

Attachments on bug 272711: 133308