Attachment #104887 for bug #236230




import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import junit.framework.AssertionFailedError;
import junit.framework.ComparisonFailure;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jdt.core.tests.model.ModelTestsUtil;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import org.eclipse.jdt.internal.core.util.SimpleDocument;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.text.edits.TextEdit;

 * <code>linesLeading</code> (e.g. ignore white spaces at the beginning of the
 * lines, including the star inside javadoc or block comments):
 * <ul>
 * 	<li>JUnit 3.8.2 workspace (71 units):
 * 	<ul>
 * 		<li>0 error</li>
 * 		<li>0 failures</li>
 * 		<li>0 failures due to old formatter</li>
 * 		<li>8 files have different lines leading spaces</li>
 * 		<li>0 files have different spaces</li>
 *		</ul></li>
 * 	<li>Eclipse 3.0 performance workspace (9951 units):
 * 	<ul>
 * 		<li>0 error</li>
 * 		<li>1 failures</li>
 * 		<li>8 failures due to old formatter</li>
 * 		<li>722 files have different lines leading spaces</li>
 * 		<li>9 files have different spaces</li>
 *		</ul></li>
 * 	<li>Eclipse 3.4 workspace (17890 units):
 * 	<ul>
 * 		<li>0 error</li>
 * 		<li>17 failures</li>
 * 		<li>21 failures due to old formatter</li>
 * 		<li>1372 files have different lines leading spaces</li>
 * 		<li>12 files have different spaces</li>
 *		</ul></li>
 *		<li>ganymede workspace (33190 units):
 *		<ul>
 * 		<li>1 error</li>
 * 		<li>21 failures due to different output while reformatting!</li>
 * 		<li>21 failures due to old formatter</li>
 * 		<li>1780 files have different line leading spaces when reformatting!</li>
 * 		<li>20 files have different spaces when reformatting!</li>
 *		</ul></li>
 * </ul>
 */
public class FormatterCommentsMassiveTests extends FormatterRegressionTests {

	private static final String LINE_SEPARATOR = org.eclipse.jdt.internal.compiler.util.Util.LINE_SEPARATOR;
	final File file;
	final IPath path;
	List failures = new ArrayList();
	List expectedFailures = new ArrayList();
	List leadingWhitespacesFailures = new ArrayList();
	List whitespacesFailures= new ArrayList();
	boolean hasSpaceFailure;
	private DefaultCodeFormatterOptions preferences;
	private final static File INPUT_DIR = new File(System.getProperty("inputDir"));
	private final static File OUTPUT_DIR;
	private final static boolean COMPARE;
	private final static String DIR = System.getProperty("dir"); //$NON-NLS-1$
	private final static String COMPARE = System.getProperty("compare"); //$NON-NLS-1$
	private final static int IGNORE_SPACES;
	private final static int ALL_SPACES = 1;	// ignore all spaces
	private final static int LINES_LEADING_SPACES = 2;	// ignore all spaces at the beginning of all lines
	private final static int ALL_COMMENTS_SPACES = 3;	// ignore all spaces inside all comments
	private final static int ALL_COMMENTS_LINES_LEADING_SPACES = 4;	// ignore all spaces at the beginning of all comments lines
	static {
		String dir = System.getProperty("outputDir"); //$NON-NLS-1$
		File outputDir = null;
		boolean compare = true;
		if (dir != null) {
			outputDir = new File(dir);
			if (!outputDir.exists()) {
				compare = false;
				System.err.println("WARNING: The output directory "+dir+" does not exist...");
				System.err.println("=> NO comparison will be done! The formatted files will be written there instead.");
				try {
	                Thread.sleep(1000);
                } catch (InterruptedException e) {
	                // skip
                }
			}
		}
		OUTPUT_DIR = outputDir;
		COMPARE = compare;
	}
	private final static int FORMAT_REPEAT  = Integer.parseInt(System.getProperty("repeat", "2")); //$NON-NLS-1$
	
	// Failures management
	final static int NO_OUTPUT_FAILURE = 0;
	final static int COMPARISON_FAILURE = 1;
	final static int REFORMATTING_FAILURE = 2;
	final static int REFORMATTING_LEADING_FAILURE = 4;
	final static int REFORMATTING_WHITESPACES_FAILURE = 5;
	final static int REFORMATTING_EXPECTED_FAILURE = 3;
	class FormattingFailure {
		String action;
		List failures = new ArrayList();
		public FormattingFailure() {
        }
		public FormattingFailure(String action) {
	        this.action = action;
        }
		public String toString() {
			if (action == null) {
				return "no output while formatting";
			}
	        return "different output while "+action;
        }
		
	}
	final static FormattingFailure[] FAILURES = new FormattingFailure[6];
	{
		FAILURES[NO_OUTPUT_FAILURE] = new FormattingFailure();
		FAILURES[COMPARISON_FAILURE] = new FormattingFailure("comparing with previous version");
		FAILURES[REFORMATTING_FAILURE] = new FormattingFailure("reformatting twice");
		FAILURES[REFORMATTING_LEADING_FAILURE] = new FormattingFailure("reformatting twice but only by leading whitespaces");
		FAILURES[REFORMATTING_WHITESPACES_FAILURE] = new FormattingFailure("reformatting twice but only by whitespaces");
		FAILURES[REFORMATTING_EXPECTED_FAILURE] = new FormattingFailure("reformatting twice but was expected");
	}
	private static final int MAX_FAILURES = Integer.parseInt(System.getProperty("maxFailures", "100")); // Max failures using string comparison
	private static boolean ASSERT_EQUALS_STRINGS = MAX_FAILURES > 0;
	private final static IPath[] EXPECTED_FAILURES = INPUT_DIR.getPath().indexOf("v34") < 0
		? new IPath[] {
			new Path("org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java"),
			new Path("org/eclipse/jdt/internal/eval/CodeSnippetSingleNameReference.java"),

			new Path("org/eclipse/team/internal/ccvs/ui/wizards/UpdateWizard.java"),
		}
		:	new IPath[] {
			// Eclipse
			new Path("org/eclipse/equinox/internal/p2/director/NewDependencyExpander.java"),
			new Path("org/eclipse/jdt/core/JavaCore.java"),
			new Path("org/eclipse/jdt/internal/codeassist/CompletionEngine.java"),

			new Path("org/eclipse/jdt/internal/core/search/JavaSearchScope.java"),
			new Path("org/eclipse/jdt/internal/eval/EvaluationContext.java"),
			new Path("org/eclipse/jdt/internal/ui/text/javadoc/JavadocContentAccess2.java"),
			new Path("org/eclipse/jdt/internal/apt/pluggable/core/filer/IdeJavaSourceOutputStream.java"),
			new Path("org/eclipse/team/internal/ccvs/ui/mappings/WorkspaceSubscriberContext.java"),
			// Ganymede
			new Path("com/ibm/icu/text/Collator.java"),
			new Path("org/apache/lucene/analysis/ISOLatin1AccentFilter.java"),
	};
	static {
		// Sort expected failures to allow binary search
		Arrays.sort(EXPECTED_FAILURES);
	}
	
public static Test suite() {
	TestSuite suite = new Suite(FormatterCommentsMassiveTests.class.getName());
	try {
		File testDir = ModelTestsUtil.getWorkspaceRoot().getLocation().toFile();
		if (DIR != null) {
			File dir = new File(DIR);
			if (dir.exists()) testDir = dir;
		}
		FileFilter filter = new FileFilter() {
			public boolean accept(File pathname) {
	            return pathname.isDirectory() || pathname.getPath().endsWith(".java");

		SimpleDateFormat format = new SimpleDateFormat();
		Date now = new Date(start);
		System.out.println("Date of test: "+format.format(now));
		System.out.print("Get all Java files located in "+INPUT_DIR+"...");
		File[] allFiles = ModelTestsUtil.getAllFiles(INPUT_DIR, filter);
		int length = allFiles.length;
		System.out.println(length+" found in " + (System.currentTimeMillis() - start) + "ms");
		for (int i=0; i<length; i++) {
			suite.addTest(new FormatterCommentsMassiveTests(allFiles[i]));
		}
//		ASSERT_EQUALS_STRINGS = length < 15000; 
    } catch (Exception e) {
    	// skip
    }

public FormatterCommentsMassiveTests(File file) {
	super("testCompare");
	this.file = file;
	this.path = new Path(file.getPath().substring(INPUT_DIR.getPath().length()+1));
}

/* (non-Javadoc)

public void setUp() throws Exception {
	super.setUp();
	this.hasSpaceFailure = false;
	this.preferences = DefaultCodeFormatterOptions.getEclipseDefaultSettings();
}

/* (non-Javadoc)

 * @see org.eclipse.jdt.core.tests.formatter.FormatterRegressionTests#tearDownSuite()
 */
public void tearDownSuite() throws Exception {
	if (OUTPUT_DIR != null) {
		if (COMPARE) {
			System.out.println("Comparison done with output files located in "+OUTPUT_DIR);
	int swFailures = this.whitespacesFailures.size();
	int slwFailures = this.leadingWhitespacesFailures.size();
	String failuresType = COMPARE != null ? "than old formatter" : "when reformatting";
	System.out.println();
	if (sFailures > 0) {
		System.out.println(sFailures+" files has still different output while reformatting!");
	}
	if (seFailures > 0) {
		System.out.println(seFailures+" files has still different output while reformatting due to old formatter bugs!");
	}
	if (slwFailures == 0) {
		System.out.println("No file has different line leading spaces "+failuresType+" :-)");
	} else {
		System.out.println(slwFailures+" files have different line leading spaces "+failuresType+"!");
	}
	if (swFailures > 0) {
		System.out.println(swFailures+" files have different spaces "+failuresType+"!");
	}
	if (this.changedHeaderFooter >0) {
		System.out.println(this.changedHeaderFooter+" differences in header/footer have been found");
	}
	if (this.changedPreTags >0) {
		System.out.println(this.changedPreTags+" differences in <pre> tags (blank lines) have been found");
	}
	System.out.println();
	if (sFailures > 0) {
		System.out.println("List of files with different output "+failuresType+":");
		for (int i=0; i<sFailures; i++) {
			System.out.println("	- "+this.failures.get(i));
		}
	}
	// skip standard model suite tear down
	System.out.println();
	int max = FAILURES.length;
	for (int i=0; i<max; i++) {
		List failures = FAILURES[i].failures;
		int size = failures.size();
		if (size > 0) {
			System.out.print(size);
			System.out.print(" file");
			if (size == 1) {
				System.out.print(" has ");
			} else {
				System.out.print("s have ");
			}
			System.out.print(FAILURES[i]);
			System.out.println('!');
		}
	}
	System.out.println();
	for (int i=0; i<max; i++) {
		List failures = FAILURES[i].failures;
		int size = failures.size();
		if (size > 0) {
			System.out.println("List of file(s) with "+FAILURES[i]+":");
			for (int j=0; j<size; j++) {
				System.out.println("	- "+failures.get(j));
			}
		}
	}
}

 * The line separators in 'actual' are converted to '\n' before the comparison.
 */
protected void assertSourceEquals(String message, String expected, String actual) {
	if (expected == null) {
		assertNull(message, actual);
		return;
	}
	if (actual == null) {
		assertEquals(message, expected, null);
		return;
	}
	expected = Util.convertToIndependantLineDelimiter(expected);
	actual = Util.convertToIndependantLineDelimiter(actual);
	if (ASSERT_EQUALS_STRINGS) {
		assertEquals(message, expected, actual);
	} else {
		assertTrue(message, actual.equals(expected));
			assertTrue(message, actual.equals(expected));
		}
	}
	catch (ComparisonFailure cf) {
		if ("true".equals(COMPARE)) {
			String trimmedExpected = expected;
			String trimmedActual = actual;
			switch (IGNORE_SPACES) {
				case ALL_SPACES:
					trimmedExpected = ModelTestsUtil.removeWhiteSpace(expected);
					trimmedActual= ModelTestsUtil.removeWhiteSpace(actual);
					if (trimmedExpected.equals(trimmedActual)) {
						this.whitespacesFailures.add(this.path);
						return;
					}
					break;
				case LINES_LEADING_SPACES:
					trimmedExpected = ModelTestsUtil.trimLinesLeadingWhitespaces(expected);
					trimmedActual= ModelTestsUtil.trimLinesLeadingWhitespaces(actual);
					if (trimmedExpected.equals(trimmedActual)) {
						this.leadingWhitespacesFailures.add(this.path);
						return;
					}
					trimmedExpected = ModelTestsUtil.removeWhiteSpace(expected);
					trimmedActual= ModelTestsUtil.removeWhiteSpace(actual);
					if (trimmedExpected.equals(trimmedActual)) {
						this.whitespacesFailures.add(this.path);
						return;
					}
					break;
			}
			if (DEBUG_TESTS && ASSERT_EQUALS_STRINGS) {
				assertEquals(message, trimmedExpected, trimmedActual);
			}
		}
		this.failures.add(this.path);
		ASSERT_EQUALS_STRINGS = this.failures.size() < MAX_FAILURES;
		throw cf;
	}
	catch (AssertionFailedError afe) {
		this.failures.add(this.path);
		throw afe;
	}
}

private String cleanAllKnownDifferences(String comment) {
	int kind = comment.charAt(1) == '/' ? 1 : comment.charAt(2) == '*' ? 3 : 2;
	String cleanedComment = comment;
	switch (kind) {
		case 1: // line comment
			cleanedComment = cleanBlankLinesAfterLineComment(comment);
			break;
		case 3: // javadoc comment
			cleanedComment = cleanHeaderAndFooter(comment);
			String newComment = cleanPreTags(cleanedComment);
			if (cleanedComment == newComment) {
				cleanedComment = cleanCodeTags(cleanedComment);
			} else {
				cleanedComment = newComment;
			}
			break;
	}
	return cleanedComment;
}
private String cleanHeaderAndFooter(String comment) {
	int start = 1; // skip starting '/'
	int length = comment.length();
	int end = length - 1; // skip ending '/'
	while (comment.charAt(start) == '*') {
		// remove all contiguous '*' in header
		start++;
	}
	while (comment.charAt(--end) == '*') {
		// remove all contiguous '*' in header
	}
	if (start > 3 || end < (length - 2)) {
		this.changedHeaderFooter++;
		return comment.substring(start, end);
	}
	return comment;
}

private String cleanBlankLinesAfterLineComment(String comment) {
	int length = comment.length();
	if (comment.charAt(length-1) == '\n') {
		length--;
		if (comment.charAt(length-1) == '\r') {
			length--;
		}
		return comment.substring(0, length);
	}
	return comment;
}

private String cleanCodeTags(String comment) {
	if (comment.indexOf("<code>") < 0) return comment;
	StringTokenizer tokenizer = new StringTokenizer(comment, "\r\n\f");
	StringBuffer buffer = new StringBuffer();
	while (tokenizer.hasMoreTokens()) {
		String line = tokenizer.nextToken();
		if (line.indexOf("<pre>") >= 0) {
			while (line.indexOf("</pre>") < 0) {
				line = tokenizer.nextToken();
			}
		} else {
			buffer.append(line);
			buffer.append("\n");
		}
	}
	this.changedCodeTags++;
	return buffer.toString();
}

private String cleanPreTags(String comment) {
	if (comment.indexOf("<pre>") < 0) return comment;
	StringTokenizer tokenizer = new StringTokenizer(comment, "\r\n\f");
	StringBuffer buffer = new StringBuffer();
	StringBuffer emptyLines = new StringBuffer();
	String previousLine = null;
	while (tokenizer.hasMoreTokens()) {
		String line = tokenizer.nextToken();
		if (line.trim() == "*") {
			if (previousLine == null || previousLine.indexOf("<pre>") < 0) {
				buffer.append(line);
				buffer.append("\n");
				continue;
			} else {
				emptyLines.append(line);
				emptyLines.append("\n");
			}
		} else if (line.indexOf("<code>") >= 0) {
			while (line.indexOf("</code>") < 0) {
				line = tokenizer.nextToken();
			}
		} else if (emptyLines.length() != 0) {
			if (line.indexOf("</pre>") < 0) {
				buffer.append(emptyLines);
				emptyLines.setLength(0);
			}
			buffer.append(line);
			buffer.append("\n");
		} else {
			buffer.append(line);
			buffer.append("\n");
		}
		previousLine = line;
	}
	this.changedPreTags++;
	return buffer.toString();
}

DefaultCodeFormatter codeFormatter() {
	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(this.preferences, getDefaultCompilerOptions());
	DefaultCodeFormatter codeFormatter = new DefaultCodeFormatter(preferences);
	return codeFormatter;
}

void compareFormattedSource() throws IOException, Exception {
	DefaultCodeFormatter codeFormatter = codeFormatter();
	String source = new String(org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(this.file, null));
	try {
		// Format the source
		String actualResult = runFormatter(codeFormatter(), source, CodeFormatter.K_COMPILATION_UNIT | CodeFormatter.F_INCLUDE_COMMENTS, 0, 0, source.length(), null);

		// Look for output to compare with
		File outputFile = new Path(OUTPUT_DIR.getPath()).append(this.path).toFile();
		if (COMPARE) {
			String expectedResult = new String(org.eclipse.jdt.internal.compiler.util.Util.getFileCharContent(outputFile, null));
			try {
				assertSourceEquals("Unexpected format output!", expectedResult, actualResult);
			}
			catch (ComparisonFailure cf) {
				FAILURES[COMPARISON_FAILURE].failures.add(this.path);
				throw cf;
			}
			catch (AssertionFailedError afe) {
				FAILURES[COMPARISON_FAILURE].failures.add(this.path);
				throw afe;
						assertEquals("Unexpected difference with formatted comment "+(i+1), Util.convertToIndependantLineDelimiter(expectedResult), Util.convertToIndependantLineDelimiter(actualResult));
					}
				}
			}
		} else {
			outputFile.getParentFile().mkdirs();
			Util.writeToFile(actualResult, outputFile.getAbsolutePath());
				String expectedResult = expectedFormattedSource(source);
				assertLineEquals(actualResult, source, expectedResult, false);
			}
		}
	}
	catch (Exception e) {

	return buffer.toString();
}

private String expectedFormattedSource(String source) {
	boolean enableNewCommentFormatter = DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT;
	try {
		DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT = false;
		DefaultCodeFormatter codeFormatter = codeFormatter();
		Scanner scanner = new Scanner(true, true, false/*nls*/, ClassFileConstants.JDK1_4/*sourceLevel*/, null/*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
		CodeSnippetParsingUtil codeSnippetParsingUtil = new CodeSnippetParsingUtil();
		CompilationUnitDeclaration compilationUnitDeclaration = codeSnippetParsingUtil.parseCompilationUnit(source.toCharArray(), getDefaultCompilerOptions(), true);
		final TypeDeclaration[] types = compilationUnitDeclaration.types;
		int headerEndPosition = types == null ? compilationUnitDeclaration.sourceEnd : types[0].declarationSourceStart;
		scanner.setSource(source.toCharArray());
		scanner.lineEnds = codeSnippetParsingUtil.recordedParsingInformation.lineEnds;
		int[][] commentsPositions = compilationUnitDeclaration.comments;
		int length = commentsPositions == null ? 0 : commentsPositions.length;
		String[] formattedComments = new String[length];
		for (int i=0; i<length; i++) {
			int[] positions = commentsPositions[i];
			int commentKind = CodeFormatter.K_JAVA_DOC;
			int commentStart = positions [0];
			int commentEnd = positions [1];
			if (commentEnd < 0) { // line or block comments have negative end position
				commentEnd = -commentEnd;
				if (commentStart > 0) { // block comments have positive start position
					commentKind = CodeFormatter.K_MULTI_LINE_COMMENT;
				} else {
					commentStart = -commentStart;
					commentKind = CodeFormatter.K_SINGLE_LINE_COMMENT;
				}
			}
			if (commentStart >= headerEndPosition) {
				int indentationLevel = getIndentationLevel(scanner, commentStart);
				formattedComments[i] = runFormatter(codeFormatter, source.substring(commentStart, commentEnd), commentKind, indentationLevel, 0, commentEnd - commentStart, LINE_SEPARATOR);
			}
		}
		SimpleDocument document = new SimpleDocument(source);
		for (int i=length-1; i>=0; i--) {
			if (formattedComments[i] != null) {
				int[] positions = commentsPositions[i];
				int commentStart = positions [0];
				int commentEnd = positions [1];
				if (commentEnd < 0) { // line or block comments have negative end position
					commentEnd = -commentEnd;
					if (commentStart < 0) { // line comments have negative start position
						commentStart = -commentStart;
					}
				}
				document.replace(commentStart, commentEnd - commentStart, formattedComments[i]);
			}
		}
		String newSource = document.get();
		String oldResult = runFormatter(codeFormatter, newSource, CodeFormatter.K_COMPILATION_UNIT, 0, 0, newSource.length(), null);
		return oldResult == null ? newSource : oldResult;
	}
	finally {
		DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT = enableNewCommentFormatter;
	}
}
private String[] formattedComments(String source, boolean old) {
	boolean enableNewCommentFormatter = DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT;
	try {
		DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT = !old;
		DefaultCodeFormatter codeFormatter = codeFormatter();
		Scanner scanner = new Scanner(true, true, false/*nls*/, ClassFileConstants.JDK1_4/*sourceLevel*/, null/*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
		CodeSnippetParsingUtil codeSnippetParsingUtil = new CodeSnippetParsingUtil();
		CompilationUnitDeclaration compilationUnitDeclaration = codeSnippetParsingUtil.parseCompilationUnit(source.toCharArray(), getDefaultCompilerOptions(), true);
		final TypeDeclaration[] types = compilationUnitDeclaration.types;
		int headerEndPosition = types == null ? compilationUnitDeclaration.sourceEnd : types[0].declarationSourceStart;
		scanner.setSource(source.toCharArray());
		scanner.lineEnds = codeSnippetParsingUtil.recordedParsingInformation.lineEnds;
		int[][] commentsPositions = compilationUnitDeclaration.comments;
		int length = commentsPositions == null ? 0 : commentsPositions.length;
		String[] formattedComments = new String[length];
		for (int i=0; i<length; i++) {
			int[] positions = commentsPositions[i];
			int commentKind = CodeFormatter.K_JAVA_DOC;
			int commentStart = positions [0];
			int commentEnd = positions [1];
			if (commentEnd < 0) { // line or block comments have negative end position
				commentEnd = -commentEnd;
				if (commentStart > 0) { // block comments have positive start position
					commentKind = CodeFormatter.K_MULTI_LINE_COMMENT;
				} else {
					commentStart = -commentStart;
					commentKind = CodeFormatter.K_SINGLE_LINE_COMMENT;
				}
			}
			if (commentStart >= headerEndPosition) {
				int indentationLevel = getIndentationLevel(scanner, commentStart);
				formattedComments[i] = runFormatter(codeFormatter, source.substring(commentStart, commentEnd), commentKind, indentationLevel, 0, commentEnd - commentStart, LINE_SEPARATOR);
			}
		}
		return formattedComments;
	}
	finally {
		DefaultCodeFormatter.ENABLE_NEW_COMMENTS_FORMAT = enableNewCommentFormatter;
	}
}

private int getIndentationLevel(Scanner scanner, int position) {
	int indentationLevel = 0;
	int numberOfIndentations = 0;
	int indentationSize;
	try {
		indentationSize = Integer.parseInt(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
	} catch (NumberFormatException nfe) {
		indentationSize = 4;
	}
	int lineNumber = scanner.getLineNumber(position);
	int lineStart = scanner.getLineStart(lineNumber);
	scanner.resetTo(lineStart, position-1);
	while (!scanner.atEnd()) {
		int ch = scanner.getNextChar();
		switch (ch) {
			case '\n':
				indentationLevel = 0;
				numberOfIndentations = 0;
				break;
			case '\t':
				numberOfIndentations++;
				indentationLevel = numberOfIndentations * indentationSize;
				break;
			default:
				indentationLevel++;
				if ((indentationLevel%indentationSize) == 0) {
					numberOfIndentations++;
				}
				break;
		}
	}
	if ((indentationLevel%indentationSize) != 0) {
		numberOfIndentations++;
		indentationLevel = numberOfIndentations * indentationSize;
	}
	return numberOfIndentations;
}

private Map getDefaultCompilerOptions() {
	Map optionsMap = new HashMap(30);
	optionsMap.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.DO_NOT_GENERATE); 

	optionsMap.put(CompilerOptions.OPTION_ReportUnusedDeclaredThrownException, CompilerOptions.IGNORE);
	optionsMap.put(CompilerOptions.OPTION_ReportUnusedDeclaredThrownExceptionWhenOverriding, CompilerOptions.DISABLED); 
	optionsMap.put(CompilerOptions.OPTION_ReportUnqualifiedFieldAccess, CompilerOptions.IGNORE);
	optionsMap.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_6);
	optionsMap.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_6); 
	optionsMap.put(CompilerOptions.OPTION_TaskTags, ""); //$NON-NLS-1$
	optionsMap.put(CompilerOptions.OPTION_TaskPriorities, ""); //$NON-NLS-1$
	optionsMap.put(CompilerOptions.OPTION_TaskCaseSensitive, CompilerOptions.DISABLED);

	optionsMap.put(CompilerOptions.OPTION_ReportSpecialParameterHidingField, CompilerOptions.DISABLED); 
	optionsMap.put(CompilerOptions.OPTION_MaxProblemPerUnit, String.valueOf(100));
	optionsMap.put(CompilerOptions.OPTION_InlineJsr, CompilerOptions.DISABLED); 
	optionsMap.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_6);
	return optionsMap;
}


	int length = EXPECTED_FAILURES.length;
	for (int i=0; i<length; i++) {
		IPath expectedFailure= EXPECTED_FAILURES[i];
		if (this.path.toString().indexOf(expectedFailure.toString()) >= 0) {
			FAILURES[REFORMATTING_EXPECTED_FAILURE].failures.add(this.path);
			return true;
		}
	}
	return false;
}

/*
private boolean runFormatterWithoutComments(CodeFormatter codeFormatter, String source, int kind, int indentationLevel, int offset, int length, String lineSeparator) {
	DefaultCodeFormatterOptions preferencesWithoutComment = DefaultCodeFormatterOptions.getEclipseDefaultSettings();
	preferencesWithoutComment.comment_format_line_comment = false;
	preferencesWithoutComment.comment_format_block_comment = false;
	preferencesWithoutComment.comment_format_javadoc_comment = false;
	DefaultCodeFormatter codeFormatterWithoutComment = new DefaultCodeFormatter(preferencesWithoutComment);

	TextEdit edit = codeFormatterWithoutComment.format(kind, source, offset, length, indentationLevel, lineSeparator);//$NON-NLS-1$
	if (edit == null) return false;
	String initialResult = org.eclipse.jdt.internal.core.util.Util.editedString(source, edit);

	int count = 1;
	String result = initialResult;
	String previousResult = result;
	while (count++ < FORMAT_REPEAT) {
		edit = codeFormatterWithoutComment.format(kind, result, 0, result.length(), indentationLevel, lineSeparator);//$NON-NLS-1$
		if (edit == null) return false;
		previousResult = result;
		result = org.eclipse.jdt.internal.core.util.Util.editedString(result, edit);
	}
	return previousResult.equals(result);
}
*/

String runFormatter(CodeFormatter codeFormatter, String source, int kind, int indentationLevel, int offset, int length, String lineSeparator) {
	TextEdit edit = codeFormatter.format(kind, source, offset, length, indentationLevel, lineSeparator);//$NON-NLS-1$
	try {
		assertNotNull("Formatted source should not be null!", edit);
	}
	catch (ComparisonFailure cf) {
		FAILURES[NO_OUTPUT_FAILURE].failures.add(this.path);
		throw cf;
	}
	catch (AssertionFailedError afe) {
		FAILURES[NO_OUTPUT_FAILURE].failures.add(this.path);
		throw afe;
	}
	String initialResult = org.eclipse.jdt.internal.core.util.Util.editedString(source, edit);

	int count = 1;
	String result = initialResult;
	String previousResult = result;
	while (count++ < FORMAT_REPEAT) {
		edit = codeFormatter.format(kind, result, 0, result.length(), indentationLevel, lineSeparator);//$NON-NLS-1$
		if (edit == null) return null;
		previousResult = result;
		result = org.eclipse.jdt.internal.core.util.Util.editedString(result, edit);
	}
	if (!previousResult.equals(result)) {

		// Try to compare without leading spaces
		String trimmedExpected = ModelTestsUtil.trimLinesLeadingWhitespaces(previousResult);
		String trimmedActual= ModelTestsUtil.trimLinesLeadingWhitespaces(result);
		if (trimmedExpected.equals(trimmedActual)) {
			FAILURES[REFORMATTING_LEADING_FAILURE].failures.add(this.path);
			this.hasSpaceFailure = true;
			return initialResult;
		}
		
		// Try to compare without spaces at all
		if (ModelTestsUtil.removeWhiteSpace(previousResult).equals(ModelTestsUtil.removeWhiteSpace(result))) {
			FAILURES[REFORMATTING_WHITESPACES_FAILURE].failures.add(this.path);
			this.hasSpaceFailure = true;
			return initialResult;
		}

		/*
		// Try to see if the formatting also fails without comments
		if (!runFormatterWithoutComments(null, source, kind, indentationLevel, offset, length, lineSeparator)) {
			return initialResult;
		}

		// format without comments is OK => there's a problem with comment formatting
		String counterString = counterToString(count-1);
		assertSourceEquals(counterString+" formatting is different from first one!", previousResult, result);
		*/
		if (!isExpectedFailure()) {
			String counterString = counterToString(count-1);
			try {
				assertSourceEquals(counterString+" formatting is different from first one!", previousResult, result);
			}
			catch (ComparisonFailure cf) {
				FAILURES[REFORMATTING_FAILURE].failures.add(this.path);
				throw cf;
			}
			catch (AssertionFailedError afe) {
				FAILURES[REFORMATTING_FAILURE].failures.add(this.path);
				throw afe;
			}
			result = previousResult;
		}
	}
	return initialResult;
}

public void testCompare() throws IOException, Exception {




		1 /* indentation level */
	);
}

/**
 * @bug 236230: [formatter] SIOOBE while formatting a compilation unit.
 * @test Ensure that no exception occurs while formatting
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=236230"
 */
public void testBug236230() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * <p>If there is an authority, it is:\n" + 
		"   * <pre>\n" + 
		"   *   //authority/device/pathSegment1/pathSegment2...</pre>\n" + 
		"   */\n" + 
		"  public String devicePath() {\n" + 
		"	  return null;\n" + 
		"  }\n" + 
		"}\n";
	formatSource(source,
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * <p>\n" + 
		"	 * If there is an authority, it is:\n" + 
		"	 * \n" + 
		"	 * <pre>\n" + 
		"	 * // authority/device/pathSegment1/pathSegment2...\n" + 
		"	 * </pre>\n" + 
		"	 */\n" + 
		"	public String devicePath() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	);
}
public void testBug236230b() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * <p>If there is an authority, it is:\n" + 
		"   * <pre>//authority/device/pathSegment1/pathSegment2...</pre>\n" + 
		"   */\n" + 
		"  public String devicePath() {\n" + 
		"	  return null;\n" + 
		"  }\n" + 
		"}\n";
	formatSource(source,
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * <p>\n" + 
		"	 * If there is an authority, it is:\n" + 
		"	 * \n" + 
		"	 * <pre>\n" + 
		"	 * // authority/device/pathSegment1/pathSegment2...\n" + 
		"	 * </pre>\n" + 
		"	 */\n" + 
		"	public String devicePath() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	);
}
public void testBug236230c() throws JavaModelException {
	this.preferences.comment_format_header = true;
	String source = 
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * <p>If there is an authority, it is:\n" + 
		"   * <pre>\n" +
		"			import java.util.List;\n" +
		"			//            CU         snippet\n" +
		"			public class X implements List {}\n" +
		"		</pre>\n" + 
		"   */\n" + 
		"  public String devicePath() {\n" + 
		"	  return null;\n" + 
		"  }\n" + 
		"}\n";
	formatSource(source,
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * <p>\n" + 
		"	 * If there is an authority, it is:\n" + 
		"	 * \n" + 
		"	 * <pre>\n" + 
		"	 * import java.util.List;\n" + 
		"	 * \n" + 
		"	 * // CU snippet\n" + 
		"	 * public class X implements List {\n" + 
		"	 * }\n" + 
		"	 * </pre>\n" + 
		"	 */\n" + 
		"	public String devicePath() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	);
}
public void testBug236230d() throws JavaModelException {
	String source = 
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"  /**\n" + 
		"   * <p>If there is an authority, it is:\n" + 
		"   * <pre>\n" +
		"			//class	body		snippet\n" +
		"			public class X {}\n" +
		"		</pre>\n" + 
		"   */\n" + 
		"  public String devicePath() {\n" + 
		"	  return null;\n" + 
		"  }\n" + 
		"}\n";
	// TODO (frederic) line comment should be formatted when F_INCLUDE_COMMENTS
	// flag will work for all snippet kinds
	formatSource(source,
		"/**\n" + 
		" * Need a javadoc comment before to get the exception.\n" + 
		" */\n" + 
		"public class Test {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * <p>\n" + 
		"	 * If there is an authority, it is:\n" + 
		"	 * \n" + 
		"	 * <pre>\n" + 
		"	 * //class	body		snippet\n" + 
		"	 * public class X {\n" + 
		"	 * }\n" + 
		"	 * </pre>\n" + 
		"	 */\n" + 
		"	public String devicePath() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	);
}
// Following tests showed possible regressions while implementing the fix...
public void testBug236230e() throws JavaModelException {
	String source = 
		"public class X02 {\n" + 
		"\n" + 
		"\n" + 
		"	/**\n" + 
		"	/**\n" + 
		"	 * Removes the Java nature from the project.\n" + 
		"	 */\n" + 
		"	void foo() {\n" + 
		"	}\n" + 
		"}\n";
	formatSource(source,
		"public class X02 {\n" + 
		"\n" + 
		"	/**\n" + 
		"	 * /** Removes the Java nature from the project.\n" + 
		"	 */\n" + 
		"	void foo() {\n" + 
		"	}\n" + 
		"}\n"
	);
}
public void testBug236230f() throws JavaModelException {
	String source = 
		"public class X03 {\n" + 
		"  /** The value of <tt>System.getProperty(\"java.version\")<tt>. **/\n" + 
		"  static final String JAVA_VERSION = System.getProperty(\"java.version\");\n" + 
		"\n" + 
		"}\n";
	formatSource(source,
		"public class X03 {\n" + 
		"	/** The value of <tt>System.getProperty(\"java.version\")<tt>. **/\n" + 
		"	static final String JAVA_VERSION = System.getProperty(\"java.version\");\n" + 
		"\n" + 
		"}\n"
	);
}
}




import org.eclipse.jdt.core.dom.*;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

/**
 * Class to test DOM/AST nodes built for Javadoc comments.
 * 
 * Most of tests are 'automatic'. It means that to add a new tests, you only need to
 * create one or several CUs and put them in org.eclipse.jdt.core.model.tests/workspace/Converter/src/javadoc/testXXX
 * folder and add the corresponding test in this class:
 * <pre>
 * public void testXXX() throws JavaModelException {
 * 	verifyComments("testXXX");
 * }
 * </pre>
 * 
 * Note that when a test fails, the easiest way to debug it is to open
 * a runtime workbench, create a project 'Converter', delete the default 'src' source folder
 * and replace it by a linked source to the 'src' folder of org.eclipse.jdt.core.model.tests/workspace/Converter/src
 * in your workspace.
 * 
 * Then open the CU on which the test fails in a ASTView and verify the offset/length
 * of the offending node located at the positions displayed in the console when the test failed...
 * 
 * Since 3.4, the failing test also provides the comparision between the source of the comment
 * and the string get from the built DOM/AST nodes in the comment (see {@link ASTConverterJavadocFlattener})
 * but this may be not enough to see precisely the origin of the problem.
 */
public class ASTConverterJavadocTest extends ConverterTestSetup {

	// Flag to know whether Converter directory should be copied from org.eclipse.jdt.core.tests.model project

		return runConversion(source, unitName, project);
	}

// NOT USED
//	class ASTConverterJavadocFlattener extends ASTVisitor {
//
//		/**
//		 * The string buffer into which the serialized representation of the AST is
//		 * written.
//		 */
//		private StringBuffer buffer;
//		
//		private String comment;
//		
//		/**
//		 * Creates a new AST printer.
//		 */
//		ASTConverterJavadocFlattener(String comment) {
//			buffer = new StringBuffer();
//			comment = comment;
//		}
//		
//		/**
//		 * Returns the string accumulated in the visit.
//		 *
//		 * @return the serialized 
//		 */
//		public String getResult() {
//			return buffer.toString();
//		}
//		
//		/**
//		 * Resets this printer so that it can be used again.
//		 */
//		public void reset() {
//			buffer.setLength(0);
//		}
//
//		/*
//		 * @see ASTVisitor#visit(ArrayType)
//		 */
//		public boolean visit(ArrayType node) {
//			node.getComponentType().accept(this);
//			buffer.append("[]");//$NON-NLS-1$
//			return false;
//		}
//	
//		/*
//		 * @see ASTVisitor#visit(BlockComment)
//		 * @since 3.0
//		 */
//		public boolean visit(BlockComment node) {
//			buffer.append(comment);
//			return false;
//		}
//	
//		/*
//		 * @see ASTVisitor#visit(Javadoc)
//		 */
//		public boolean visit(Javadoc node) {
//			
//			// ignore deprecated node.getComment()
//			buffer.append("/**");//$NON-NLS-1$
//			ASTNode e = null;
//			int start = 3;
//			for (Iterator it = node.tags().iterator(); it.hasNext(); ) {
//				e = (ASTNode) it.next();
//				try {
//					buffer.append(comment.substring(start, e.getStartPosition()-node.getStartPosition()));
//					start = e.getStartPosition()-node.getStartPosition();
//				} catch (IndexOutOfBoundsException ex) {
//					// do nothing
//				}
//				e.accept(this);
//				start += e.getLength();
//			}
//			buffer.append(comment.substring(start, node.getLength()));
//			return false;
//		}
//	
//		/*
//		 * @see ASTVisitor#visit(LineComment)
//		 * @since 3.0
//		 */
//		public boolean visit(LineComment node) {
//			buffer.append(comment);
//			return false;
//		}
//	
//		/*
//		 * @see ASTVisitor#visit(MemberRef)
//		 * @since 3.0
//		 */
//		public boolean visit(MemberRef node) {
//			if (node.getQualifier() != null) {
//				node.getQualifier().accept(this);
//			}
//			buffer.append("#");//$NON-NLS-1$
//			node.getName().accept(this);
//			return true;
//		}
//		
//		/*
//		 * @see ASTVisitor#visit(MethodRef)
//		 * @since 3.0
//		 */
//		public boolean visit(MethodRef node) {
//			if (node.getQualifier() != null) {
//				node.getQualifier().accept(this);
//			}
//			buffer.append("#");//$NON-NLS-1$
//			node.getName().accept(this);
//			buffer.append("(");//$NON-NLS-1$
//			for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
//				MethodRefParameter e = (MethodRefParameter) it.next();
//				e.accept(this);
//				if (it.hasNext()) {
//					buffer.append(",");//$NON-NLS-1$
//				}
//			}
//			buffer.append(")");//$NON-NLS-1$
//			return true;
//		}
//		
//		/*
//		 * @see ASTVisitor#visit(MethodRefParameter)
//		 * @since 3.0
//		 */
//		public boolean visit(MethodRefParameter node) {
//			node.getType().accept(this);
//			if (node.getName() != null) {
//				buffer.append(" ");//$NON-NLS-1$
//				node.getName().accept(this);
//			}
//			return true;
//		}
//
//		/*
//		 * @see ASTVisitor#visit(TagElement)
//		 * @since 3.0
//		 */
//		public boolean visit(TagElement node) {
//			Javadoc javadoc = null;
//			int start = 0;
//			if (node.isNested()) {
//				// nested tags are always enclosed in braces
//				buffer.append("{");//$NON-NLS-1$
//				javadoc = (Javadoc) node.getParent().getParent();
//				start++;
//			} else {
//				javadoc = (Javadoc) node.getParent();
//			}
//			start += node.getStartPosition()-javadoc.getStartPosition();
//			if (node.getTagName() != null) {
//				buffer.append(node.getTagName());
//				start += node.getTagName().length();
//			}
//			for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
//				ASTNode e = (ASTNode) it.next();
//				try {
//					buffer.append(comment.substring(start, e.getStartPosition()-javadoc.getStartPosition()));
//					start = e.getStartPosition()-javadoc.getStartPosition();
//				} catch (IndexOutOfBoundsException ex) {
//					// do nothing
//				}
//				start += e.getLength();
//				e.accept(this);
//			}
//			if (node.isNested()) {
//				buffer.append("}");//$NON-NLS-1$
//			}
//			return true;
//		}
//		
//		/*
//		 * @see ASTVisitor#visit(TextElement)
//		 * @since 3.0
//		 */
//		public boolean visit(TextElement node) {
//			buffer.append(node.getText());
//			return false;
//		}
//
//		/*
//		 * @see ASTVisitor#visit(PrimitiveType)
//		 */
//		public boolean visit(PrimitiveType node) {
//			buffer.append(node.getPrimitiveTypeCode().toString());
//			return false;
//		}
//	
//		/*
//		 * @see ASTVisitor#visit(QualifiedName)
//		 */
//		public boolean visit(QualifiedName node) {
//			node.getQualifier().accept(this);
//			buffer.append(".");//$NON-NLS-1$
//			node.getName().accept(this);
//			return false;
//		}
//
//		/*
//		 * @see ASTVisitor#visit(SimpleName)
//		 */
//		public boolean visit(SimpleName node) {
//			buffer.append(node.getIdentifier());
//			return false;
//		}
//
//		/*
//		 * @see ASTVisitor#visit(SimpleName)
//		 */
//		public boolean visit(SimpleType node) {
//			node.getName().accept(this);
//			return false;
//		}
//	}

	private char getNextChar(char[] source, int idx) {
			// get next char
			char ch = source[idx];

	 */
	private void verifyPositions(Javadoc docComment, char[] source) {
		boolean stop = stopOnFailure;
		stopOnFailure = false;
		// Verify javadoc start and end position
		int start = docComment.getStartPosition();
		int end = start+docComment.getLength()-1;

		assumeTrue(prefix+"Misplaced javadoc end at <"+tagStart+'>', source[tagStart-1] == '*' && source[tagStart] == '/');
		assumeEquals(prefix+"Wrong javadoc length at <"+end+">: ", tagStart, end);
		stopOnFailure = stop;
		if (stop && failures.size() > 0) {
			String expected = new String(source, docComment.getStartPosition(), docComment.getLength());
			ASTConverterJavadocFlattener flattener = new ASTConverterJavadocFlattener(expected);
			docComment.accept(flattener);
			assertEquals("Unexpected errors while verifying javadoc comment positions!", expected, flattener.getResult());
		}
	}

	/**




/*******************************************************************************
 * Copyright (c) 2000, 2008 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.dom;

import java.util.Iterator;

import org.eclipse.jdt.core.dom.*;

public class ASTConverterJavadocFlattener extends ASTVisitor {

	/**
	 * The string buffer into which the serialized representation of the AST is
	 * written.
	 */
	private StringBuffer buffer;
	private int indent = 0;
	private String comment;
		
/**
 * Creates a new AST printer.
 */
ASTConverterJavadocFlattener(String comment) {
	buffer = new StringBuffer();
	this.comment = comment;
}

/**
 * Returns the string accumulated in the visit.
 *
 * @return the serialized 
 */
public String getResult() {
	return buffer.toString();
}

/**
 * Resets this printer so that it can be used again.
 */
public void reset() {
	buffer.setLength(0);
}

/*
 * @see ASTVisitor#visit(ArrayType)
 */
public boolean visit(ArrayType node) {
	node.getComponentType().accept(this);
	buffer.append("[]");//$NON-NLS-1$
	return false;
}

/*
 * @see ASTVisitor#visit(BlockComment)
 * @since 3.0
 */
public boolean visit(BlockComment node) {
	buffer.append(comment);
	return false;
}

/*
 * @see ASTVisitor#visit(Javadoc)
 */
public boolean visit(Javadoc javadoc) {
	printIndent();
	this.buffer.append("/**");//$NON-NLS-1$
	for (Iterator it = javadoc.tags().iterator(); it.hasNext(); ) {
		ASTNode e = (ASTNode) it.next();
		e.accept(this);
	}
	this.buffer.append("\n */\n");//$NON-NLS-1$
	return false;
}

private void printIndent() {
	for (int i=0; i<this.indent; i++) {
		buffer.append('\t');
	}
}

/*
private void printNewLine() {
	buffer.append('\n');
	printIndent();
	buffer.append(" * ");
}
*/

/*
 * @see ASTVisitor#visit(LineComment)
 * @since 3.0
 */
public boolean visit(LineComment node) {
	buffer.append(comment);
	return false;
}

/*
 * @see ASTVisitor#visit(MemberRef)
 * @since 3.0
 */
public boolean visit(MemberRef node) {
	if (node.getQualifier() != null) {
		node.getQualifier().accept(this);
	}
	buffer.append("#");//$NON-NLS-1$
	node.getName().accept(this);
	return true;
}

/*
 * @see ASTVisitor#visit(MethodRef)
 * @since 3.0
 */
public boolean visit(MethodRef node) {
	if (node.getQualifier() != null) {
		node.getQualifier().accept(this);
	}
	buffer.append("#");//$NON-NLS-1$
	node.getName().accept(this);
	buffer.append("(");//$NON-NLS-1$
	for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
		MethodRefParameter e = (MethodRefParameter) it.next();
		e.accept(this);
		if (it.hasNext()) {
			buffer.append(",");//$NON-NLS-1$
		}
	}
	buffer.append(")");//$NON-NLS-1$
	return true;
}

/*
 * @see ASTVisitor#visit(MethodRefParameter)
 * @since 3.0
 */
public boolean visit(MethodRefParameter node) {
	node.getType().accept(this);
	if (node.getName() != null) {
		buffer.append(" ");//$NON-NLS-1$
		node.getName().accept(this);
	}
	return true;
}

/*
 * @see ASTVisitor#visit(TagElement)
 * @since 3.0
 */
public boolean visit(TagElement node) {
	if (node.isNested()) {
		// nested tags are always enclosed in braces
		this.buffer.append("{");//$NON-NLS-1$
	} else {
		// top-level tags always begin on a new line
		this.buffer.append("\n * ");//$NON-NLS-1$
	}
	boolean previousRequiresWhiteSpace = false;
	if (node.getTagName() != null) {
		this.buffer.append(node.getTagName());
		previousRequiresWhiteSpace = true;
	}
	boolean previousRequiresNewLine = false;
	for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
		ASTNode e = (ASTNode) it.next();
		// assume text elements include necessary leading and trailing whitespace
		// but Name, MemberRef, MethodRef, and nested TagElement do not include white space
		boolean currentIncludesWhiteSpace = (e instanceof TextElement);
		if (previousRequiresNewLine && currentIncludesWhiteSpace) {
			this.buffer.append("\n * ");//$NON-NLS-1$
		}
		previousRequiresNewLine = currentIncludesWhiteSpace;
		// add space if required to separate
		if (previousRequiresWhiteSpace && !currentIncludesWhiteSpace) {
			this.buffer.append(" "); //$NON-NLS-1$
		}
		e.accept(this);
		previousRequiresWhiteSpace = !currentIncludesWhiteSpace && !(e instanceof TagElement);
	}
	if (node.isNested()) {
		this.buffer.append("}");//$NON-NLS-1$
	}
	return false;
}

/*
 * @see ASTVisitor#visit(TextElement)
 * @since 3.0
 */
public boolean visit(TextElement node) {
	buffer.append(node.getText());
	return false;
}

/*
 * @see ASTVisitor#visit(PrimitiveType)
 */
public boolean visit(PrimitiveType node) {
	buffer.append(node.getPrimitiveTypeCode().toString());
	return false;
}

/*
 * @see ASTVisitor#visit(QualifiedName)
 */
public boolean visit(QualifiedName node) {
	node.getQualifier().accept(this);
	buffer.append(".");//$NON-NLS-1$
	node.getName().accept(this);
	return false;
}

/*
 * @see ASTVisitor#visit(SimpleName)
 */
public boolean visit(SimpleName node) {
	buffer.append(node.getIdentifier());
	return false;
}

/*
 * @see ASTVisitor#visit(SimpleName)
 */
public boolean visit(SimpleType node) {
	node.getName().accept(this);
	return false;
}
}

Lines 1715-1722 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/Scribe.java (-1 / +2 lines)
1715	}	1715	}
1716		1716
1717	// 3 - process snippet (@see JavaDocRegion#formatCodeSnippet)	1717	// 3 - process snippet (@see JavaDocRegion#formatCodeSnippet)
		1718	// include comments in case of line comments are present in the snippet
1718	String formattedSnippet = convertedSnippet;	1719	String formattedSnippet = convertedSnippet;
1719	TextEdit edit= CommentFormatterUtil.format2(CodeFormatter.K_UNKNOWN, convertedSnippet, 0, this.lineSeparator, this.formatter.preferences.getMap());	1720	TextEdit edit= CommentFormatterUtil.format2(CodeFormatter.K_UNKNOWN \| CodeFormatter.F_INCLUDE_COMMENTS, convertedSnippet, 0, this.lineSeparator, this.formatter.preferences.getMap());
1720	if (edit != null) {	1721	if (edit != null) {
1721	formattedSnippet= CommentFormatterUtil.evaluateFormatterEdit(convertedSnippet, edit, null);	1722	formattedSnippet= CommentFormatterUtil.evaluateFormatterEdit(convertedSnippet, edit, null);
1722	}	1723	}




	}

	// Add the text
	FormatJavadocText text = new FormatJavadocText(start, end-1, lineStart, htmlIndex, htmlDepth);
	if (this.javadocTextEnd > 0 && end >= this.javadocTextEnd) {
		// Special case on javadoc text end, need to retrieve the space
		// position by rescanning the text
		int restart = this.spacePosition == -1 ? start : this.spacePosition;
		this.scanner.resetTo(restart, end-1/* before last star*/);
		try {
			if (this.scanner.getNextToken() == TerminalTokens.TokenNameEOF) {
				textEnd = this.spacePosition;
			}
		}
		catch (InvalidInputException iie) {
			// do nothing
		}
	}
	FormatJavadocText text = new FormatJavadocText(start, textEnd-1, lineStart, htmlIndex, htmlDepth);
	previousBlock.addText(text);
	previousBlock.sourceStart = previousStart;
	if (lineStart == previousBlock.lineStart) {




import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import org.eclipse.jdt.internal.formatter.comment.CommentRegion;


	private TextEdit probeFormatting(String source, int indentationLevel, String lineSeparator, IRegion[] regions, boolean includeComments) {
		if (PROBING_SCANNER == null) {
			// scanner use to check if the kind could be K_JAVA_DOC, K_MULTI_LINE_COMMENT or K_SINGLE_LINE_COMMENT
			// do not tokenize white spaces to get single comments even with spaces before...
			PROBING_SCANNER = new Scanner(true, false/*do not tokenize whitespaces*/, false/*nls*/, ClassFileConstants.JDK1_6, ClassFileConstants.JDK1_6, null/*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
		}
		PROBING_SCANNER.setSource(source.toCharArray());
		

		int offset = coveredRegion.getOffset();
		int length = coveredRegion.getLength();
		
		PROBING_SCANNER.resetTo(offset, offset + length - 1);
		try {
			int kind = -1;
			switch(PROBING_SCANNER.getNextToken()) {
				case ITerminalSymbols.TokenNameCOMMENT_BLOCK :
					if (PROBING_SCANNER.getNextToken() == TerminalTokens.TokenNameEOF) {
						kind = K_MULTI_LINE_COMMENT;
					}
					break;
				case ITerminalSymbols.TokenNameCOMMENT_LINE :
					if (PROBING_SCANNER.getNextToken() == TerminalTokens.TokenNameEOF) {
						kind = K_SINGLE_LINE_COMMENT;
					}
					break;
				case ITerminalSymbols.TokenNameCOMMENT_JAVADOC :
					if (PROBING_SCANNER.getNextToken() == TerminalTokens.TokenNameEOF) {
						kind = K_JAVA_DOC;
					}
					break;

Lines 62-68 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java (-66 / +40 lines)
62	protected int javadocTextStart, javadocTextEnd = -1;	62	protected int javadocTextStart, javadocTextEnd = -1;
63	protected int firstTagPosition;	63	protected int firstTagPosition;
64	protected int index, lineEnd;	64	protected int index, lineEnd;
65	protected int tokenPreviousPosition, lastIdentifierEndPosition, starPosition, spacePosition;	65	protected int tokenPreviousPosition, lastIdentifierEndPosition, starPosition;
66	protected int textStart, memberStart;	66	protected int textStart, memberStart;
67	protected int tagSourceStart, tagSourceEnd;	67	protected int tagSourceStart, tagSourceEnd;
68	protected int inlineTagStart;	68	protected int inlineTagStart;
Lines 133-139 Link Here
133	this.deprecated = false;	133	this.deprecated = false;
134	this.lastLinePtr = getLineNumber(javadocEnd);	134	this.lastLinePtr = getLineNumber(javadocEnd);
135	this.textStart = -1;	135	this.textStart = -1;
136	this.spacePosition = -1;
137	char previousChar = 0;	136	char previousChar = 0;
138	int invalidTagLineEnd = -1;	137	int invalidTagLineEnd = -1;
139	int invalidInlineTagLineEnd = -1;	138	int invalidInlineTagLineEnd = -1;
Lines 163-171 Link Here
163	this.javadocTextStart = this.index;	162	this.javadocTextStart = this.index;
164	}	163	}
165	this.lineEnd = (this.linePtr == this.lastLinePtr) ? this.javadocEnd: this.scanner.getLineEnd(this.linePtr) - 1;	164	this.lineEnd = (this.linePtr == this.lastLinePtr) ? this.javadocEnd: this.scanner.getLineEnd(this.linePtr) - 1;
		165	this.javadocTextEnd = this.javadocEnd - 2; // supposed text end, it will be refined later...
166		166
167	// Loop on each comment character	167	// Loop on each comment character
		168	int textEndPosition = -1;
168	while (!abort && this.index < this.javadocEnd) {	169	while (!abort && this.index < this.javadocEnd) {
		170
		171	// Store previous position and char
169	previousPosition = this.index;	172	previousPosition = this.index;
170	previousChar = nextCharacter;	173	previousChar = nextCharacter;
171		174
Lines 206-215 Link Here
206	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);	209	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);
207	}	210	}
208	validComment = false;	211	validComment = false;
209	int textEndPosition = previousPosition;
210	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
211	textEndPosition = this.spacePosition;
212	}
213	if (this.textStart != -1 && this.textStart < textEndPosition) {	212	if (this.textStart != -1 && this.textStart < textEndPosition) {
214	if (pushText) pushText(this.textStart, textEndPosition);	213	if (pushText) pushText(this.textStart, textEndPosition);
215	}	214	}
Lines 219-228 Link Here
219	}	218	}
220	if (previousChar == '{') {	219	if (previousChar == '{') {
221	if (this.textStart != -1) {	220	if (this.textStart != -1) {
222	int textEndPosition = this.inlineTagStart;
223	if (isFormatterParser && this.spacePosition == (this.inlineTagStart-1)) {
224	textEndPosition = this.spacePosition;
225	}
226	if (this.textStart < textEndPosition) {	221	if (this.textStart < textEndPosition) {
227	if (pushText) pushText(this.textStart, textEndPosition);	222	if (pushText) pushText(this.textStart, textEndPosition);
228	}	223	}
Lines 230-240 Link Here
230	this.inlineTagStarted = true;	225	this.inlineTagStarted = true;
231	invalidInlineTagLineEnd = this.lineEnd;	226	invalidInlineTagLineEnd = this.lineEnd;
232	} else if (this.textStart != -1 && this.textStart < invalidTagLineEnd) {	227	} else if (this.textStart != -1 && this.textStart < invalidTagLineEnd) {
233	int textEndPosition = invalidTagLineEnd;	228	if (pushText) pushText(this.textStart, invalidTagLineEnd);
234	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
235	textEndPosition = this.spacePosition;
236	}
237	if (pushText) pushText(this.textStart, textEndPosition);
238	}	229	}
239	this.scanner.resetTo(this.index, this.javadocEnd);	230	this.scanner.resetTo(this.index, this.javadocEnd);
240	this.currentTokenType = -1; // flush token cache at line begin	231	this.currentTokenType = -1; // flush token cache at line begin
Lines 250-276 Link Here
250	}	241	}
251	this.textStart = this.tagSourceEnd+1;	242	this.textStart = this.tagSourceEnd+1;
252	invalidTagLineEnd = this.lineEnd;	243	invalidTagLineEnd = this.lineEnd;
		244	textEndPosition = this.index;
253	}	245	}
254	} catch (InvalidInputException e) {	246	} catch (InvalidInputException e) {
255	consumeToken();	247	consumeToken();
256	}	248	}
257	} else if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {	249	} else {
258	refreshReturnStatement();	250	textEndPosition = this.index;
259	} else if (isFormatterParser) {	251	if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {
260	if (this.textStart == -1) this.textStart = previousPosition;	252	refreshReturnStatement();
		253	} else if (isFormatterParser) {
		254	if (this.textStart == -1) this.textStart = previousPosition;
		255	}
261	}	256	}
262	this.lineStarted = true;	257	this.lineStarted = true;
263	break;	258	break;
264	case '\r':	259	case '\r':
265	case '\n':	260	case '\n':
266	if (this.lineStarted) {	261	if (this.lineStarted) {
267	int textEndPosition = previousPosition;	262	if (isFormatterParser && !ScannerHelper.isWhitespace(previousChar)) {
268	if (isFormatterParser) {	263	textEndPosition = previousPosition;
269	if (ScannerHelper.isWhitespace(previousChar)) {
270	textEndPosition = this.spacePosition;
271	} else {
272	this.spacePosition = previousPosition;
273	}
274	}	264	}
275	if (this.textStart != -1 && this.textStart < textEndPosition) {	265	if (this.textStart != -1 && this.textStart < textEndPosition) {
276	if (pushText) pushText(this.textStart, textEndPosition);	266	if (pushText) pushText(this.textStart, textEndPosition);
Lines 287-296 Link Here
287	}	277	}
288	if (this.inlineTagStarted) {	278	if (this.inlineTagStarted) {
289	if (pushText) {	279	if (pushText) {
290	int textEndPosition = previousPosition;
291	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
292	textEndPosition = this.spacePosition;
293	}
294	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {	280	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {
295	pushText(this.textStart, textEndPosition);	281	pushText(this.textStart, textEndPosition);
296	}	282	}
Lines 304-309 Link Here
304	}	290	}
305	}	291	}
306	this.lineStarted = true;	292	this.lineStarted = true;
		293	textEndPosition = this.index;
307	break;	294	break;
308	case '{' :	295	case '{' :
309	if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {	296	if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {
Lines 318-332 Link Here
318	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);	305	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);
319	}	306	}
320	if (pushText) {	307	if (pushText) {
321	int textEndPosition = previousPosition;
322	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
323	textEndPosition = this.spacePosition;
324	}
325	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {	308	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {
326	pushText(this.textStart, textEndPosition);	309	pushText(this.textStart, textEndPosition);
327	}	310	}
328	refreshInlineTagPosition(textEndPosition);	311	refreshInlineTagPosition(textEndPosition);
329	}	312	}
		313	textEndPosition = this.index;
		314	} else if (peekChar() != '@') {
		315	textEndPosition = this.index;
330	}	316	}
331	if (!this.lineStarted) {	317	if (!this.lineStarted) {
332	this.textStart = previousPosition;	318	this.textStart = previousPosition;
Lines 352-360 Link Here
352	case '\u000c' : /* FORM FEED */	338	case '\u000c' : /* FORM FEED */
353	case ' ' : /* SPACE */	339	case ' ' : /* SPACE */
354	case '\t' : /* HORIZONTAL TABULATION */	340	case '\t' : /* HORIZONTAL TABULATION */
355	// Store first space position while formatting	341	// Do not include trailing spaces in text while formatting
356	if (isFormatterParser && !ScannerHelper.isWhitespace(previousChar)) {	342	if (isFormatterParser) {
357	this.spacePosition = previousPosition;	343	if (!ScannerHelper.isWhitespace(previousChar)) {
		344	textEndPosition = previousPosition;
		345	}
		346	} else if (this.lineStarted) {
		347	textEndPosition = this.index;
358	}	348	}
359	break;	349	break;
360	case '/':	350	case '/':
Lines 368-375 Link Here
368	// html tags are meaningful for formatter parser	358	// html tags are meaningful for formatter parser
369	int initialIndex = this.index;	359	int initialIndex = this.index;
370	this.scanner.resetTo(this.index, this.javadocEnd);	360	this.scanner.resetTo(this.index, this.javadocEnd);
371	int endTextPosition = ScannerHelper.isWhitespace(previousChar) ? this.spacePosition : previousPosition;	361	if (!ScannerHelper.isWhitespace(previousChar)) {
372	if (parseHtmlTag(previousPosition, endTextPosition)) {	362	textEndPosition = previousPosition;
		363	}
		364	if (parseHtmlTag(previousPosition, textEndPosition)) {
373	break;	365	break;
374	}	366	}
375	if (this.abort) return false;	367	if (this.abort) return false;
Lines 384-389 Link Here
384	this.textStart = previousPosition;	376	this.textStart = previousPosition;
385	}	377	}
386	this.lineStarted = true;	378	this.lineStarted = true;
		379	textEndPosition = this.index;
387	break;	380	break;
388	}	381	}
389	}	382	}
Lines 398-415 Link Here
398	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);	391	this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, end);
399	}	392	}
400	if (pushText) {	393	if (pushText) {
401	int textEndPosition = this.javadocTextEnd;
402	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
403	textEndPosition = this.spacePosition;
404	}
405	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {	394	if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {
406	pushText(this.textStart, textEndPosition);	395	pushText(this.textStart, textEndPosition);
407	}	396	}
408	refreshInlineTagPosition(textEndPosition);	397	refreshInlineTagPosition(textEndPosition);
409	}	398	}
410	this.inlineTagStarted = false;	399	this.inlineTagStarted = false;
411	} else if (pushText && this.lineStarted && this.textStart != -1 && this.textStart <= this.javadocTextEnd) {	400	} else if (pushText && this.lineStarted && this.textStart != -1 && this.textStart <= textEndPosition) {
412	pushText(this.textStart, this.starPosition);	401	pushText(this.textStart, textEndPosition);
413	}	402	}
414	updateDocComment();	403	updateDocComment();
415	} catch (Exception ex) {	404	} catch (Exception ex) {
Lines 1539-1551 Link Here
1539	* Note that end of comment may be preceding by several contiguous '*' chars.	1528	* Note that end of comment may be preceding by several contiguous '*' chars.
1540	*/	1529	*/
1541	protected boolean verifyEndLine(int textPosition) {	1530	protected boolean verifyEndLine(int textPosition) {
1542	boolean isDomParser = (this.kind & DOM_PARSER) != 0;	1531	boolean domParser = (this.kind & DOM_PARSER) != 0;
1543	boolean isFormatterParser = (this.kind & FORMATTER_COMMENT_PARSER) != 0;
1544	// Special case for inline tag	1532	// Special case for inline tag
1545	if (this.inlineTagStarted) {	1533	if (this.inlineTagStarted) {
1546	// expecting closing brace	1534	// expecting closing brace
1547	if (peekChar() == '}') {	1535	if (peekChar() == '}') {
1548	if (isDomParser \|\| isFormatterParser) {	1536	if (domParser) {
1549	createTag();	1537	createTag();
1550	pushText(textPosition, this.starPosition);	1538	pushText(textPosition, this.starPosition);
1551	}	1539	}
Lines 1556-1585 Link Here
1556		1544
1557	int startPosition = this.index;	1545	int startPosition = this.index;
1558	int previousPosition = this.index;	1546	int previousPosition = this.index;
1559	int spacePos = this.index;
1560	this.starPosition = -1;	1547	this.starPosition = -1;
1561	char ch = readChar();	1548	char ch = readChar();
1562	char previousChar = ch;
1563	nextChar: while (true) {	1549	nextChar: while (true) {
1564	switch (ch) {	1550	switch (ch) {
1565	case '\r':	1551	case '\r':
1566	case '\n':	1552	case '\n':
1567	if (isDomParser \|\| isFormatterParser) {	1553	if (domParser) {
1568	createTag();	1554	createTag();
1569	int textEndPosition = previousPosition;	1555	pushText(textPosition, previousPosition);
1570	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
1571	textEndPosition = spacePos;
1572	}
1573	pushText(textPosition, textEndPosition);
1574	}	1556	}
1575	this.index = previousPosition;	1557	this.index = previousPosition;
1576	return true;	1558	return true;
1577	case '\u000c' : /* FORM FEED */	1559	case '\u000c' : /* FORM FEED */
1578	case ' ' : /* SPACE */	1560	case ' ' : /* SPACE */
1579	case '\t' : /* HORIZONTAL TABULATION */	1561	case '\t' : /* HORIZONTAL TABULATION */
1580	if (isFormatterParser && previousChar != ch && !ScannerHelper.isWhitespace(previousChar)) {
1581	this.spacePosition = previousPosition;
1582	}
1583	if (this.starPosition >= 0) break nextChar;	1562	if (this.starPosition >= 0) break nextChar;
1584	break;	1563	break;
1585	case '*':	1564	case '*':
Lines 1587-1599 Link Here
1587	break;	1566	break;
1588	case '/':	1567	case '/':
1589	if (this.starPosition >= textPosition) {	1568	if (this.starPosition >= textPosition) {
1590	if (isDomParser \|\| isFormatterParser) {	1569	if (domParser) {
1591	createTag();	1570	createTag();
1592	int textEndPosition = this.starPosition;	1571	pushText(textPosition, this.starPosition);
1593	if (isFormatterParser && ScannerHelper.isWhitespace(previousChar)) {
1594	textEndPosition = this.spacePosition;
1595	}
1596	pushText(textPosition, textEndPosition);
1597	}	1572	}
1598	return true;	1573	return true;
1599	}	1574	}
Lines 1603-1609 Link Here
1603		1578
1604	}	1579	}
1605	previousPosition = this.index;	1580	previousPosition = this.index;
1606	previousChar = ch;
1607	ch = readChar();	1581	ch = readChar();
1608	}	1582	}
1609	this.index = startPosition;	1583	this.index = startPosition;

Return to bug 236230

Lines 475-496 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/FormatterCommentParser.java (-16 / +1 lines)
475	}	475	}
476		476
477	// Add the text	477	// Add the text
478	int textEnd = end;	478	FormatJavadocText text = new FormatJavadocText(start, end-1, lineStart, htmlIndex, htmlDepth);
479	if (this.javadocTextEnd > 0 && end >= this.javadocTextEnd) {
480	// Special case on javadoc text end, need to retrieve the space
481	// position by rescanning the text
482	int restart = this.spacePosition == -1 ? start : this.spacePosition;
483	this.scanner.resetTo(restart, end-1/* before last star*/);
484	try {
485	if (this.scanner.getNextToken() == TerminalTokens.TokenNameEOF) {
486	textEnd = this.spacePosition;
487	}
488	}
489	catch (InvalidInputException iie) {
490	// do nothing
491	}
492	}
493	FormatJavadocText text = new FormatJavadocText(start, textEnd-1, lineStart, htmlIndex, htmlDepth);
494	previousBlock.addText(text);	479	previousBlock.addText(text);
495	previousBlock.sourceStart = previousStart;	480	previousBlock.sourceStart = previousStart;
496	if (lineStart == previousBlock.lineStart) {	481	if (lineStart == previousBlock.lineStart) {

Lines 977-980 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterCommentsBugsTest.java (+202 lines)
977	1 /* indentation level */	977	1 /* indentation level */
978	);	978	);
979	}	979	}
		980
		981	/**
		982	* @bug 236230: [formatter] SIOOBE while formatting a compilation unit.
		983	* @test Ensure that no exception occurs while formatting
		984	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=236230"
		985	*/
		986	public void testBug236230() throws JavaModelException {
		987	String source =
		988	"/**\n" +
		989	" * Need a javadoc comment before to get the exception.\n" +
		990	" */\n" +
		991	"public class Test {\n" +
		992	"\n" +
		993	" /**\n" +
		994	" * <p>If there is an authority, it is:\n" +
		995	" * <pre>\n" +
		996	" * //authority/device/pathSegment1/pathSegment2...</pre>\n" +
		997	" */\n" +
		998	" public String devicePath() {\n" +
		999	" return null;\n" +
		1000	" }\n" +
		1001	"}\n";
		1002	formatSource(source,
		1003	"/**\n" +
		1004	" * Need a javadoc comment before to get the exception.\n" +
		1005	" */\n" +
		1006	"public class Test {\n" +
		1007	"\n" +
		1008	" /**\n" +
		1009	" * <p>\n" +
		1010	" * If there is an authority, it is:\n" +
		1011	" * \n" +
		1012	" * <pre>\n" +
		1013	" * // authority/device/pathSegment1/pathSegment2...\n" +
		1014	" * </pre>\n" +
		1015	" */\n" +
		1016	" public String devicePath() {\n" +
		1017	" return null;\n" +
		1018	" }\n" +
		1019	"}\n"
		1020	);
		1021	}
		1022	public void testBug236230b() throws JavaModelException {
		1023	String source =
		1024	"/**\n" +
		1025	" * Need a javadoc comment before to get the exception.\n" +
		1026	" */\n" +
		1027	"public class Test {\n" +
		1028	"\n" +
		1029	" /**\n" +
		1030	" * <p>If there is an authority, it is:\n" +
		1031	" * <pre>//authority/device/pathSegment1/pathSegment2...</pre>\n" +
		1032	" */\n" +
		1033	" public String devicePath() {\n" +
		1034	" return null;\n" +
		1035	" }\n" +
		1036	"}\n";
		1037	formatSource(source,
		1038	"/**\n" +
		1039	" * Need a javadoc comment before to get the exception.\n" +
		1040	" */\n" +
		1041	"public class Test {\n" +
		1042	"\n" +
		1043	" /**\n" +
1044	" * <p>\n" +
1045	" * If there is an authority, it is:\n" +
1046	" * \n" +
1047	" * <pre>\n" +
1048	" * // authority/device/pathSegment1/pathSegment2...\n" +
1049	" * </pre>\n" +
1050	" */\n" +
1051	" public String devicePath() {\n" +
1052	" return null;\n" +
1053	" }\n" +
1054	"}\n"
1055	);
1056	}
1057	public void testBug236230c() throws JavaModelException {
1058	this.preferences.comment_format_header = true;
1059	String source =
1060	"/**\n" +
1061	" * Need a javadoc comment before to get the exception.\n" +
1062	" */\n" +
1063	"public class Test {\n" +
1064	"\n" +
1065	" /**\n" +
1066	" * <p>If there is an authority, it is:\n" +
1067	" * <pre>\n" +
1068	" import java.util.List;\n" +
1069	" // CU snippet\n" +
1070	" public class X implements List {}\n" +
1071	" </pre>\n" +
1072	" */\n" +
1073	" public String devicePath() {\n" +
1074	" return null;\n" +
1075	" }\n" +
1076	"}\n";
1077	formatSource(source,
1078	"/**\n" +
1079	" * Need a javadoc comment before to get the exception.\n" +
1080	" */\n" +
1081	"public class Test {\n" +
1082	"\n" +
1083	" /**\n" +
1084	" * <p>\n" +
1085	" * If there is an authority, it is:\n" +
1086	" * \n" +
1087	" * <pre>\n" +
1088	" * import java.util.List;\n" +
1089	" * \n" +
1090	" * // CU snippet\n" +
1091	" * public class X implements List {\n" +
1092	" * }\n" +
1093	" * </pre>\n" +
1094	" */\n" +
1095	" public String devicePath() {\n" +
1096	" return null;\n" +
1097	" }\n" +
1098	"}\n"
1099	);
1100	}
1101	public void testBug236230d() throws JavaModelException {
1102	String source =
1103	"/**\n" +
1104	" * Need a javadoc comment before to get the exception.\n" +
1105	" */\n" +
1106	"public class Test {\n" +
1107	"\n" +
1108	" /**\n" +
1109	" * <p>If there is an authority, it is:\n" +
1110	" * <pre>\n" +
1111	" //class body snippet\n" +
1112	" public class X {}\n" +
1113	" </pre>\n" +
1114	" */\n" +
1115	" public String devicePath() {\n" +
1116	" return null;\n" +
1117	" }\n" +
1118	"}\n";
1119	// TODO (frederic) line comment should be formatted when F_INCLUDE_COMMENTS
1120	// flag will work for all snippet kinds
1121	formatSource(source,
1122	"/**\n" +
1123	" * Need a javadoc comment before to get the exception.\n" +
1124	" */\n" +
1125	"public class Test {\n" +
1126	"\n" +
1127	" /**\n" +
1128	" * <p>\n" +
1129	" * If there is an authority, it is:\n" +
1130	" * \n" +
1131	" * <pre>\n" +
1132	" * //class body snippet\n" +
1133	" * public class X {\n" +
1134	" * }\n" +
1135	" * </pre>\n" +
1136	" */\n" +
1137	" public String devicePath() {\n" +
1138	" return null;\n" +
1139	" }\n" +
1140	"}\n"
1141	);
1142	}
1143	// Following tests showed possible regressions while implementing the fix...
1144	public void testBug236230e() throws JavaModelException {
1145	String source =
1146	"public class X02 {\n" +
1147	"\n" +
1148	"\n" +
1149	" /**\n" +
1150	" /**\n" +
1151	" * Removes the Java nature from the project.\n" +
1152	" */\n" +
1153	" void foo() {\n" +
1154	" }\n" +
1155	"}\n";
1156	formatSource(source,
1157	"public class X02 {\n" +
1158	"\n" +
1159	" /**\n" +
1160	" * /** Removes the Java nature from the project.\n" +
1161	" */\n" +
1162	" void foo() {\n" +
1163	" }\n" +
1164	"}\n"
1165	);
1166	}
1167	public void testBug236230f() throws JavaModelException {
1168	String source =
1169	"public class X03 {\n" +
1170	" / The value of <tt>System.getProperty(\"java.version\")<tt>. /\n" +
1171	" static final String JAVA_VERSION = System.getProperty(\"java.version\");\n" +
1172	"\n" +
1173	"}\n";
1174	formatSource(source,
1175	"public class X03 {\n" +
1176	" / The value of <tt>System.getProperty(\"java.version\")<tt>. /\n" +
1177	" static final String JAVA_VERSION = System.getProperty(\"java.version\");\n" +
1178	"\n" +
1179	"}\n"
1180	);
1181	}
980	}	1182	}

Lines 30-35 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocTest.java (-217 / +31 lines)
30	import org.eclipse.jdt.core.dom.*;	30	import org.eclipse.jdt.core.dom.*;
31	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	31	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
32		32
		33	/**
		34	* Class to test DOM/AST nodes built for Javadoc comments.
		35	*
		36	* Most of tests are 'automatic'. It means that to add a new tests, you only need to
		37	* create one or several CUs and put them in org.eclipse.jdt.core.model.tests/workspace/Converter/src/javadoc/testXXX
		38	* folder and add the corresponding test in this class:
		39	* <pre>
		40	* public void testXXX() throws JavaModelException {
		41	* verifyComments("testXXX");
		42	* }
		43	* </pre>
		44	*
		45	* Note that when a test fails, the easiest way to debug it is to open
		46	* a runtime workbench, create a project 'Converter', delete the default 'src' source folder
		47	* and replace it by a linked source to the 'src' folder of org.eclipse.jdt.core.model.tests/workspace/Converter/src
		48	* in your workspace.
		49	*
		50	* Then open the CU on which the test fails in a ASTView and verify the offset/length
		51	* of the offending node located at the positions displayed in the console when the test failed...
		52	*
		53	* Since 3.4, the failing test also provides the comparision between the source of the comment
		54	* and the string get from the built DOM/AST nodes in the comment (see {@link ASTConverterJavadocFlattener})
		55	* but this may be not enough to see precisely the origin of the problem.
		56	*/
33	public class ASTConverterJavadocTest extends ConverterTestSetup {	57	public class ASTConverterJavadocTest extends ConverterTestSetup {
34		58
35	// Flag to know whether Converter directory should be copied from org.eclipse.jdt.core.tests.model project	59	// Flag to know whether Converter directory should be copied from org.eclipse.jdt.core.tests.model project
Lines 244-464 Link Here
244	return runConversion(source, unitName, project);	268	return runConversion(source, unitName, project);
245	}	269	}
246		270
247	// NOT USED
248	// class ASTConverterJavadocFlattener extends ASTVisitor {
249	//
250	// /**
251	// * The string buffer into which the serialized representation of the AST is
252	// * written.
253	// */
254	// private StringBuffer buffer;
255	//
256	// private String comment;
257	//
258	// /**
259	// * Creates a new AST printer.
260	// */
261	// ASTConverterJavadocFlattener(String comment) {
262	// buffer = new StringBuffer();
263	// comment = comment;
264	// }
265	//
266	// /**
267	// * Returns the string accumulated in the visit.
268	// *
269	// * @return the serialized
270	// */
271	// public String getResult() {
272	// return buffer.toString();
273	// }
274	//
275	// /**
276	// * Resets this printer so that it can be used again.
277	// */
278	// public void reset() {
279	// buffer.setLength(0);
280	// }
281	//
282	// /*
283	// * @see ASTVisitor#visit(ArrayType)
284	// */
285	// public boolean visit(ArrayType node) {
286	// node.getComponentType().accept(this);
287	// buffer.append("[]");//$NON-NLS-1$
288	// return false;
289	// }
290	//
291	// /*
292	// * @see ASTVisitor#visit(BlockComment)
293	// * @since 3.0
294	// */
295	// public boolean visit(BlockComment node) {
296	// buffer.append(comment);
297	// return false;
298	// }
299	//
300	// /*
301	// * @see ASTVisitor#visit(Javadoc)
302	// */
303	// public boolean visit(Javadoc node) {
304	//
305	// // ignore deprecated node.getComment()
306	// buffer.append("/**");//$NON-NLS-1$
307	// ASTNode e = null;
308	// int start = 3;
309	// for (Iterator it = node.tags().iterator(); it.hasNext(); ) {
310	// e = (ASTNode) it.next();
311	// try {
312	// buffer.append(comment.substring(start, e.getStartPosition()-node.getStartPosition()));
313	// start = e.getStartPosition()-node.getStartPosition();
314	// } catch (IndexOutOfBoundsException ex) {
315	// // do nothing
316	// }
317	// e.accept(this);
318	// start += e.getLength();
319	// }
320	// buffer.append(comment.substring(start, node.getLength()));
321	// return false;
322	// }
323	//
324	// /*
325	// * @see ASTVisitor#visit(LineComment)
326	// * @since 3.0
327	// */
328	// public boolean visit(LineComment node) {
329	// buffer.append(comment);
330	// return false;
331	// }
332	//
333	// /*
334	// * @see ASTVisitor#visit(MemberRef)
335	// * @since 3.0
336	// */
337	// public boolean visit(MemberRef node) {
338	// if (node.getQualifier() != null) {
339	// node.getQualifier().accept(this);
340	// }
341	// buffer.append("#");//$NON-NLS-1$
342	// node.getName().accept(this);
343	// return true;
344	// }
345	//
346	// /*
347	// * @see ASTVisitor#visit(MethodRef)
348	// * @since 3.0
349	// */
350	// public boolean visit(MethodRef node) {
351	// if (node.getQualifier() != null) {
352	// node.getQualifier().accept(this);
353	// }
354	// buffer.append("#");//$NON-NLS-1$
355	// node.getName().accept(this);
356	// buffer.append("(");//$NON-NLS-1$
357	// for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
358	// MethodRefParameter e = (MethodRefParameter) it.next();
359	// e.accept(this);
360	// if (it.hasNext()) {
361	// buffer.append(",");//$NON-NLS-1$
362	// }
363	// }
364	// buffer.append(")");//$NON-NLS-1$
365	// return true;
366	// }
367	//
368	// /*
369	// * @see ASTVisitor#visit(MethodRefParameter)
370	// * @since 3.0
371	// */
372	// public boolean visit(MethodRefParameter node) {
373	// node.getType().accept(this);
374	// if (node.getName() != null) {
375	// buffer.append(" ");//$NON-NLS-1$
376	// node.getName().accept(this);
377	// }
378	// return true;
379	// }
380	//
381	// /*
382	// * @see ASTVisitor#visit(TagElement)
383	// * @since 3.0
384	// */
385	// public boolean visit(TagElement node) {
386	// Javadoc javadoc = null;
387	// int start = 0;
388	// if (node.isNested()) {
389	// // nested tags are always enclosed in braces
390	// buffer.append("{");//$NON-NLS-1$
391	// javadoc = (Javadoc) node.getParent().getParent();
392	// start++;
393	// } else {
394	// javadoc = (Javadoc) node.getParent();
395	// }
396	// start += node.getStartPosition()-javadoc.getStartPosition();
397	// if (node.getTagName() != null) {
398	// buffer.append(node.getTagName());
399	// start += node.getTagName().length();
400	// }
401	// for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
402	// ASTNode e = (ASTNode) it.next();
403	// try {
404	// buffer.append(comment.substring(start, e.getStartPosition()-javadoc.getStartPosition()));
405	// start = e.getStartPosition()-javadoc.getStartPosition();
406	// } catch (IndexOutOfBoundsException ex) {
407	// // do nothing
408	// }
409	// start += e.getLength();
410	// e.accept(this);
411	// }
412	// if (node.isNested()) {
413	// buffer.append("}");//$NON-NLS-1$
414	// }
415	// return true;
416	// }
417	//
418	// /*
419	// * @see ASTVisitor#visit(TextElement)
420	// * @since 3.0
421	// */
422	// public boolean visit(TextElement node) {
423	// buffer.append(node.getText());
424	// return false;
425	// }
426	//
427	// /*
428	// * @see ASTVisitor#visit(PrimitiveType)
429	// */
430	// public boolean visit(PrimitiveType node) {
431	// buffer.append(node.getPrimitiveTypeCode().toString());
432	// return false;
433	// }
434	//
435	// /*
436	// * @see ASTVisitor#visit(QualifiedName)
437	// */
438	// public boolean visit(QualifiedName node) {
439	// node.getQualifier().accept(this);
440	// buffer.append(".");//$NON-NLS-1$
441	// node.getName().accept(this);
442	// return false;
443	// }
444	//
445	// /*
446	// * @see ASTVisitor#visit(SimpleName)
447	// */
448	// public boolean visit(SimpleName node) {
449	// buffer.append(node.getIdentifier());
450	// return false;
451	// }
452	//
453	// /*
454	// * @see ASTVisitor#visit(SimpleName)
455	// */
456	// public boolean visit(SimpleType node) {
457	// node.getName().accept(this);
458	// return false;
459	// }
460	// }
461
462	private char getNextChar(char[] source, int idx) {	271	private char getNextChar(char[] source, int idx) {
463	// get next char	272	// get next char
464	char ch = source[idx];	273	char ch = source[idx];
Lines 820-826 Link Here
820	*/	629	*/
821	private void verifyPositions(Javadoc docComment, char[] source) {	630	private void verifyPositions(Javadoc docComment, char[] source) {
822	boolean stop = stopOnFailure;	631	boolean stop = stopOnFailure;
823	// stopOnFailure = false;	632	stopOnFailure = false;
824	// Verify javadoc start and end position	633	// Verify javadoc start and end position
825	int start = docComment.getStartPosition();	634	int start = docComment.getStartPosition();
826	int end = start+docComment.getLength()-1;	635	int end = start+docComment.getLength()-1;
Lines 845-851 Link Here
845	assumeTrue(prefix+"Misplaced javadoc end at <"+tagStart+'>', source[tagStart-1] == '*' && source[tagStart] == '/');	654	assumeTrue(prefix+"Misplaced javadoc end at <"+tagStart+'>', source[tagStart-1] == '*' && source[tagStart] == '/');
846	assumeEquals(prefix+"Wrong javadoc length at <"+end+">: ", tagStart, end);	655	assumeEquals(prefix+"Wrong javadoc length at <"+end+">: ", tagStart, end);
847	stopOnFailure = stop;	656	stopOnFailure = stop;
848	assertTrue(!stop \|\| failures.size()==0);	657	if (stop && failures.size() > 0) {
		658	String expected = new String(source, docComment.getStartPosition(), docComment.getLength());
		659	ASTConverterJavadocFlattener flattener = new ASTConverterJavadocFlattener(expected);
		660	docComment.accept(flattener);
		661	assertEquals("Unexpected errors while verifying javadoc comment positions!", expected, flattener.getResult());
		662	}
849	}	663	}
850		664
851	/**	665	/**

Added Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterJavadocFlattener.java (+236 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 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.dom;
12
13	import java.util.Iterator;
14
15	import org.eclipse.jdt.core.dom.*;
16
17	public class ASTConverterJavadocFlattener extends ASTVisitor {
18
19	/**
20	* The string buffer into which the serialized representation of the AST is
21	* written.
22	*/
23	private StringBuffer buffer;
24	private int indent = 0;
25	private String comment;
26
27	/**
28	* Creates a new AST printer.
29	*/
30	ASTConverterJavadocFlattener(String comment) {
31	buffer = new StringBuffer();
32	this.comment = comment;
33	}
34
35	/**
36	* Returns the string accumulated in the visit.
37	*
38	* @return the serialized
39	*/
40	public String getResult() {
41	return buffer.toString();
42	}
43
44	/**
45	* Resets this printer so that it can be used again.
46	*/
47	public void reset() {
48	buffer.setLength(0);
49	}
50
51	/*
52	* @see ASTVisitor#visit(ArrayType)
53	*/
54	public boolean visit(ArrayType node) {
55	node.getComponentType().accept(this);
56	buffer.append("[]");//$NON-NLS-1$
57	return false;
58	}
59
60	/*
61	* @see ASTVisitor#visit(BlockComment)
62	* @since 3.0
63	*/
64	public boolean visit(BlockComment node) {
65	buffer.append(comment);
66	return false;
67	}
68
69	/*
70	* @see ASTVisitor#visit(Javadoc)
71	*/
72	public boolean visit(Javadoc javadoc) {
73	printIndent();
74	this.buffer.append("/**");//$NON-NLS-1$
75	for (Iterator it = javadoc.tags().iterator(); it.hasNext(); ) {
76	ASTNode e = (ASTNode) it.next();
77	e.accept(this);
78	}
79	this.buffer.append("\n */\n");//$NON-NLS-1$
80	return false;
81	}
82
83	private void printIndent() {
84	for (int i=0; i<this.indent; i++) {
85	buffer.append('\t');
86	}
87	}
88
89	/*
90	private void printNewLine() {
91	buffer.append('\n');
92	printIndent();
93	buffer.append(" * ");
94	}
95	*/
96
97	/*
98	* @see ASTVisitor#visit(LineComment)
99	* @since 3.0
100	*/
101	public boolean visit(LineComment node) {
102	buffer.append(comment);
103	return false;
104	}
105
106	/*
107	* @see ASTVisitor#visit(MemberRef)
108	* @since 3.0
109	*/
110	public boolean visit(MemberRef node) {
111	if (node.getQualifier() != null) {
112	node.getQualifier().accept(this);
113	}
114	buffer.append("#");//$NON-NLS-1$
115	node.getName().accept(this);
116	return true;
117	}
118
119	/*
120	* @see ASTVisitor#visit(MethodRef)
121	* @since 3.0
122	*/
123	public boolean visit(MethodRef node) {
124	if (node.getQualifier() != null) {
125	node.getQualifier().accept(this);
126	}
127	buffer.append("#");//$NON-NLS-1$
128	node.getName().accept(this);
129	buffer.append("(");//$NON-NLS-1$
130	for (Iterator it = node.parameters().iterator(); it.hasNext(); ) {
131	MethodRefParameter e = (MethodRefParameter) it.next();
132	e.accept(this);
133	if (it.hasNext()) {
134	buffer.append(",");//$NON-NLS-1$
135	}
136	}
137	buffer.append(")");//$NON-NLS-1$
138	return true;
139	}
140
141	/*
142	* @see ASTVisitor#visit(MethodRefParameter)
143	* @since 3.0
144	*/
145	public boolean visit(MethodRefParameter node) {
146	node.getType().accept(this);
147	if (node.getName() != null) {
148	buffer.append(" ");//$NON-NLS-1$
149	node.getName().accept(this);
150	}
151	return true;
152	}
153
154	/*
155	* @see ASTVisitor#visit(TagElement)
156	* @since 3.0
157	*/
158	public boolean visit(TagElement node) {
159	if (node.isNested()) {
160	// nested tags are always enclosed in braces
161	this.buffer.append("{");//$NON-NLS-1$
162	} else {
163	// top-level tags always begin on a new line
164	this.buffer.append("\n * ");//$NON-NLS-1$
165	}
166	boolean previousRequiresWhiteSpace = false;
167	if (node.getTagName() != null) {
168	this.buffer.append(node.getTagName());
169	previousRequiresWhiteSpace = true;
170	}
171	boolean previousRequiresNewLine = false;
172	for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
173	ASTNode e = (ASTNode) it.next();
174	// assume text elements include necessary leading and trailing whitespace
175	// but Name, MemberRef, MethodRef, and nested TagElement do not include white space
176	boolean currentIncludesWhiteSpace = (e instanceof TextElement);
177	if (previousRequiresNewLine && currentIncludesWhiteSpace) {
178	this.buffer.append("\n * ");//$NON-NLS-1$
179	}
180	previousRequiresNewLine = currentIncludesWhiteSpace;
181	// add space if required to separate
182	if (previousRequiresWhiteSpace && !currentIncludesWhiteSpace) {
183	this.buffer.append(" "); //$NON-NLS-1$
184	}
185	e.accept(this);
186	previousRequiresWhiteSpace = !currentIncludesWhiteSpace && !(e instanceof TagElement);
187	}
188	if (node.isNested()) {
189	this.buffer.append("}");//$NON-NLS-1$
190	}
191	return false;
192	}
193
194	/*
195	* @see ASTVisitor#visit(TextElement)
196	* @since 3.0
197	*/
198	public boolean visit(TextElement node) {
199	buffer.append(node.getText());
200	return false;
201	}
202
203	/*
204	* @see ASTVisitor#visit(PrimitiveType)
205	*/
206	public boolean visit(PrimitiveType node) {
207	buffer.append(node.getPrimitiveTypeCode().toString());
208	return false;
209	}
210
211	/*
212	* @see ASTVisitor#visit(QualifiedName)
213	*/
214	public boolean visit(QualifiedName node) {
215	node.getQualifier().accept(this);
216	buffer.append(".");//$NON-NLS-1$
217	node.getName().accept(this);
218	return false;
219	}
220
221	/*
222	* @see ASTVisitor#visit(SimpleName)
223	*/
224	public boolean visit(SimpleName node) {
225	buffer.append(node.getIdentifier());
226	return false;
227	}
228
229	/*
230	* @see ASTVisitor#visit(SimpleName)
231	*/
232	public boolean visit(SimpleType node) {
233	node.getName().accept(this);
234	return false;
235	}
236	}