Attachment #151464 for bug #199265




import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression;

		TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT,
		TerminalTokens.TokenNameGREATER
	};
	private int chunkKind;
	public int lastLocalDeclarationSourceStart;
	private Scanner localScanner;
	public DefaultCodeFormatterOptions preferences;

		messageSend.traverse(builder, scope);
		return builder;
	}
	public boolean checkChunkStart(int kind) {
		if (this.chunkKind != kind) {
			this.chunkKind = kind;
			return true;
		}
		return false;
	}

	private boolean commentStartsBlock(int start, int end) {
		this.localScanner.resetTo(start, end);

					for (int i = 0; i < fragmentsSize - 1; i++) {
						ASTNode fragment = fragments[i];
						fragment.traverse(this, scope);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						if (this.scribe.lastNumberOfNewLines == 1) {
							// a new line has been inserted by printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT)
							this.scribe.indentationLevel = binaryExpressionAlignment.breakIndentationLevel;
						}
						if (this.preferences.wrap_before_binary_operator) {

						}
					}
					fragments[fragmentsSize - 1].traverse(this, scope);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					ok = true;
				} catch(AlignmentException e){
					this.scribe.redoAlignment(e);


		if (memberAlignment != null) {
			this.scribe.alignFragment(memberAlignment, 2);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		} else {
			this.scribe.space();
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
	}

	private void format(ImportReference importRef, boolean isLast) {
		this.scribe.printNextToken(TerminalTokens.TokenNameimport);
		if (!isLast) this.scribe.blank_lines_between_import_groups = this.preferences.blank_lines_between_import_groups;
		this.scribe.space();
		if (importRef.isStatic()) {
			this.scribe.printNextToken(TerminalTokens.TokenNamestatic);

			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		}
		if (isLast) {
			this.scribe.blank_lines_between_import_groups = -1;
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.IMPORT_TRAILING_COMMENT);
		} else {
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.NO_TRAILING_COMMENT);
			this.scribe.blank_lines_between_import_groups = -1;
		}
		this.scribe.printNewLine();
	}


					if (i != length - 1) {
						this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_multiple_field_declarations);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						this.scribe.alignFragment(multiFieldDeclarationsAlignment, i);

						if (this.preferences.insert_space_after_comma_in_multiple_field_declarations) {

					} else {
						this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
						this.scribe.alignFragment(fieldAlignment, 2);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					}
				}
				ok = true;

					for (int i = 0; i < superInterfaceLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_superinterfaces);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							this.scribe.alignFragment(interfaceAlignment, i+1);
							if (this.preferences.insert_space_after_comma_in_superinterfaces) {
								this.scribe.space();

									if (this.preferences.insert_space_after_comma_in_enum_declarations) {
										this.scribe.space();
									}
									this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
									if (fieldDeclaration.initialization instanceof QualifiedAllocationExpression) {
										this.scribe.printNewLine();
									}

						if (this.preferences.insert_space_after_comma_in_enum_declarations) {
							this.scribe.space();
						}
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						if (fieldDeclaration.initialization instanceof QualifiedAllocationExpression) {
							this.scribe.printNewLine();
						}

			}
			if (isNextToken(TerminalTokens.TokenNameSEMICOLON)) {
				this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				if (hasConstants
						|| ((enumConstantsLength - length) != 0)
						|| typeDeclaration.methods != null

				}
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		if (class_declaration_brace.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {
			this.scribe.unIndent();
		}

			}
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		if (DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED.equals(block_brace_position)) {
			this.scribe.unIndent();
		}

						for (int j = 0; j < argumentLength; j++) {
							if (j > 0) {
								this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_method_invocation_arguments);
								this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							}
							this.scribe.alignFragment(argumentsAlignment, j);
							if (j > 0 && this.preferences.insert_space_after_comma_in_method_invocation_arguments) {

								for (int j = 0; j < argumentLength; j++) {
									if (j > 0) {
										this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_method_invocation_arguments);
										this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
									}
									this.scribe.alignFragment(argumentsAlignment, j);
									if (j > 0 && this.preferences.insert_space_after_comma_in_method_invocation_arguments) {

					}
					if (isNextToken(TerminalTokens.TokenNameSEMICOLON)) {
						this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					}
					if (i != max - 1) {
						this.scribe.printNewLine();

		while(isNextToken(TerminalTokens.TokenNameSEMICOLON)) {
			this.scribe.printComment();
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
		if (hasSemiColon && isFirst) {
			this.scribe.printNewLine();

		final Statement[] statements = block.statements;
		statements[0].traverse(this, scope);
		this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE, true);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
	}

	private void formatLeftCurlyBrace(final int line, final String bracePosition) {

			if (insertSpaceAfterComma) {
				this.scribe.space();
			}
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
	}


						for (int i = 0; i < argumentsLength; i++) {
							if (i > 0) {
								this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_method_invocation_arguments);
								this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							}
							this.scribe.alignFragment(argumentsAlignment, i);
							if (i > 0 && this.preferences.insert_space_after_comma_in_method_invocation_arguments) {

				for (int i = 0; i < argumentsLength; i++) {
					if (i > 0) {
						this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_method_invocation_arguments);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					}
					if (i > 0 && this.preferences.insert_space_after_comma_in_method_invocation_arguments) {
						this.scribe.space();

					for (int i = 0; i < argumentLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, spaceBeforeComma);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.alignFragment(argumentsAlignment, i);
						if (i > 0 && spaceAfterComma) {

					for (int i = 0; i < argumentLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, spaceBeforeComma);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.alignFragment(argumentsAlignment, i);
						if (i > 0 && spaceAfterComma) {

			this.scribe.printNewLine();
			this.scribe.indent();
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			this.scribe.unIndent();
		} else {
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
	}


				this.scribe.indent();
			}
			this.scribe.printNextToken(TerminalTokens.TokenNameLBRACE, insertSpaceBeforeBrace);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
	}
	private void formatStatements(BlockScope scope, final Statement[] statements, boolean insertNewLineAfterLastStatement) {
		int statementsLength = statements.length;

			statement.traverse(this, scope);
			if (statement instanceof Expression) {
				this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				if (i != statementsLength - 1) {
					if (!(statement instanceof EmptyStatement) && !(statements[i + 1] instanceof EmptyStatement)) {
						this.scribe.printNewLine();

						LocalDeclaration nextLocal = (LocalDeclaration) statements[i + 1];
						if (currentLocal.declarationSourceStart != nextLocal.declarationSourceStart) {
							this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							if (i != statementsLength - 1) {
								if (!(statement instanceof EmptyStatement) && !(statements[i + 1] instanceof EmptyStatement)) {
									this.scribe.printNewLine();

						}
					} else {
						this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						if (i != statementsLength - 1) {
							if (!(statement instanceof EmptyStatement) && !(statements[i + 1] instanceof EmptyStatement)) {
								this.scribe.printNewLine();

					}
				} else {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					if (i != statementsLength - 1) {
						if (!(statement instanceof EmptyStatement) && !(statements[i + 1] instanceof EmptyStatement)) {
							this.scribe.printNewLine();

					for (int i = 0; i < thrownExceptionsLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, spaceBeforeComma);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							this.scribe.alignFragment(throwsAlignment, i);
							if (spaceAfterComma) {
								this.scribe.space();

						}
						if (isNextToken(TerminalTokens.TokenNameSEMICOLON)) {
							this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.printNewLine();
						// realign to the proper value

		} else if (isNextToken(TerminalTokens.TokenNameSEMICOLON)) {
			// the only body declaration is an empty declaration (';')
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
		this.scribe.printComment();
		this.scribe.exitMemberAlignment(memberAlignment);

				case TerminalTokens.TokenNameCOMMENT_JAVADOC :
				case TerminalTokens.TokenNameCOMMENT_BLOCK :
				case TerminalTokens.TokenNameCOMMENT_LINE :
	    			this.scribe.printComment(token, Scribe.NO_TRAILING_COMMENT);
	    			break;
			}
		} catch(InvalidInputException e) {

					for (int i = 0; i < argumentLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_allocation_expression);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.alignFragment(argumentsAlignment, i);
						if (i > 0 && this.preferences.insert_space_after_comma_in_allocation_expression) {

			defaultValue.traverse(this, (BlockScope) null);
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


						expressions[0].traverse(this, scope);
						for (int i = 1; i < expressionsLength; i++) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_array_initializer);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							this.scribe.alignFragment(arrayInitializerAlignment, i);
							if (this.preferences.insert_space_after_comma_in_array_initializer) {
								this.scribe.space();

							if (i == expressionsLength - 1) {
								if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
									this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_array_initializer);
									this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
								}
							}
						}

				expressions[0].traverse(this, scope);
				if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
					this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_array_initializer);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				if (insert_new_line_after_opening_brace) {
					this.scribe.unIndent();

				this.scribe.printNextToken(TerminalTokens.TokenNameLBRACE, this.preferences.insert_space_before_opening_brace_in_array_initializer);
				if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
					this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_array_initializer);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE, this.preferences.insert_space_between_empty_braces_in_array_initializer);
			} else {
				formatOpeningBrace(array_initializer_brace_position, this.preferences.insert_space_before_opening_brace_in_array_initializer);
				if (isNextToken(TerminalTokens.TokenNameCOMMA)) {
					this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_array_initializer);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE, this.preferences.insert_space_between_empty_braces_in_array_initializer);
				if (array_initializer_brace_position.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {

			assertStatement.exceptionArgument.traverse(this, scope);
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


			this.scribe.printNextToken(TerminalTokens.TokenNameIdentifier, true);
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


			this.scribe.space();
			this.scribe.printQualifiedReference(compilationUnitDeclaration.currentPackage.sourceEnd, false/*do not expect parenthesis*/);
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			int blankLinesAfterPackage = this.preferences.blank_lines_after_package;
			if (blankLinesAfterPackage > 0) {
				this.scribe.printEmptyLines(blankLinesAfterPackage);

				}
			}
			int importLength = imports.length;
			int savedNumberOfLineToPreserve = this.preferences.number_of_empty_lines_to_preserve;
			if (importLength != 1) {
				format(imports[0], false);
    			for (int i = 1; i < importLength - 1; i++) {
    				format(imports[i], false);
    			}
    			format(imports[importLength - 1], true);
    			this.preferences.number_of_empty_lines_to_preserve = savedNumberOfLineToPreserve;
			} else {
				format(imports[0], true);
			}
			this.preferences.number_of_empty_lines_to_preserve = savedNumberOfLineToPreserve;

			int blankLinesAfterImports = this.preferences.blank_lines_after_imports;
			if (blankLinesAfterImports > 0) {

    				this.scribe.space();
    			}
    			conditionalExpression.valueIfTrue.traverse(this, scope);
    			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
    			this.scribe.alignFragment(conditionalExpressionAlignment, 1);
    			this.scribe.printNextToken(TerminalTokens.TokenNameCOLON, this.preferences.insert_space_before_colon_in_conditional);


				this.scribe.printIndentationIfNecessary();
			}
			this.scribe.scanner.resetTo(constructorDeclaration.declarationSourceEnd + 1, this.scribe.scannerEndPosition - 1);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			switch(this.scribe.scanner.source[this.scribe.scanner.currentPosition]) {
				case '\n' :
					this.scribe.scanner.currentPosition++;

				}
			}
			this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			if (constructor_declaration_brace.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {
				this.scribe.unIndent();
			}
		} else {
			// no method body
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
		return false;
	}

			this.scribe.printNextToken(TerminalTokens.TokenNameIdentifier, true);
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


				action.traverse(this, scope);
				if (action instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				this.scribe.printNewLine();
				this.scribe.unIndent();


		this.scribe.printNextToken(TerminalTokens.TokenNameRPAREN, this.preferences.insert_space_before_closing_paren_in_while);
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


			this.scribe.printNewLine();
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}
	// field is an enum constant

				this.scribe.printNewLine();
			}
			this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			if (enum_constant_brace.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {
				this.scribe.unIndent();
			}

					for (int i = 0; i < argumentLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_explicit_constructor_call_arguments);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.alignFragment(argumentsAlignment, i);
						if (i > 0 && this.preferences.insert_space_after_comma_in_explicit_constructor_call_arguments) {

			this.scribe.printNextToken(TerminalTokens.TokenNameRPAREN, this.preferences.insert_space_between_empty_parens_in_method_invocation);
		}
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}
	/**

			}
			if (action instanceof Expression) {
				this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			}
		} else {
			/*

						if (this.preferences.insert_space_after_comma_in_for_inits) {
							this.scribe.space();
						}
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					}
				}
			}

					if (this.preferences.insert_space_after_comma_in_for_increments) {
						this.scribe.space();
					}
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
			}
		}

			}
			if (action instanceof Expression) {
				this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			}
		} else {
			/*

						thenStatement.traverse(this, scope);
						if (thenStatement instanceof Expression) {
							this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						ok = true;
					} catch (AlignmentException e) {

				thenStatement.traverse(this, scope);
				if (thenStatement instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				if (elseStatement != null) {
					this.scribe.printNewLine();
				}
			} else {
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				this.scribe.printNewLine();
				this.scribe.indent();
				thenStatement.traverse(this, scope);
				if (thenStatement instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				if (elseStatement != null) {
					this.scribe.printNewLine();

				elseStatement.traverse(this, scope);
				if (elseStatement instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
			} else {
				this.scribe.printNewLine();

				elseStatement.traverse(this, scope);
				if (elseStatement instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				this.scribe.unIndent();
			}

		statement.traverse(this, scope);
		if (statement instanceof Expression) {
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
		return false;
	}

				this.scribe.printIndentationIfNecessary();
			}
			this.scribe.scanner.resetTo(methodDeclaration.declarationSourceEnd + 1, this.scribe.scannerEndPosition - 1);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			if (!this.scribe.scanner.atEnd()) {
				switch(this.scribe.scanner.source[this.scribe.scanner.currentPosition]) {
					case '\n' :

				}
			}
			this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
			if (method_declaration_brace.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {
				this.scribe.unIndent();
			}
		} else {
			// no method body
			this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
			this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		}
		return false;
	}

					for (int i = 0; i < argumentLength; i++) {
						if (i > 0) {
							this.scribe.printNextToken(TerminalTokens.TokenNameCOMMA, this.preferences.insert_space_before_comma_in_allocation_expression);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						}
						this.scribe.alignFragment(argumentsAlignment, i);
						if (i > 0 && this.preferences.insert_space_after_comma_in_allocation_expression) {

		 * Print the semi-colon
		 */
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}
	public boolean visit(SingleMemberAnnotation annotation, BlockScope scope) {

		}
		this.scribe.checkNLSTag(stringLiteral.sourceStart);
		this.scribe.printNextToken(TerminalTokens.TokenNameStringLiteral);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		if (numberOfParens > 0) {
			manageClosingParenthesizedExpression(stringLiteral, numberOfParens);
		}

				for (int i = 0; i < fragmentsSize - 1; i++) {
					ASTNode fragment = fragments[i];
					fragment.traverse(this, scope);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					if (this.scribe.lastNumberOfNewLines == 1) {
						// a new line has been inserted by printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT)
						this.scribe.indentationLevel = binaryExpressionAlignment.breakIndentationLevel;
					}
					this.scribe.alignFragment(binaryExpressionAlignment, i);

					}
				}
				fragments[fragmentsSize - 1].traverse(this, scope);
				this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				ok = true;
			} catch(AlignmentException e){
				this.scribe.redoAlignment(e);

						this.scribe.unIndent();
					}
					statement.traverse(this, scope);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					wasACase = true;
					wasAStatement = false;
					if (this.preferences.indent_switchstatements_compare_to_cases) {

					 * Print the semi-colon
					 */
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
					this.scribe.printNewLine();
				} else if (statement instanceof LocalDeclaration) {
					LocalDeclaration currentLocal = (LocalDeclaration) statement;

								 * Print the semi-colon
								 */
								this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
								this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
								this.scribe.printNewLine();
							}
						} else {

							 * Print the semi-colon
							 */
							this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
							this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
							this.scribe.printNewLine();
						}
					} else {

						 * Print the semi-colon
						 */
						this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
						this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
						this.scribe.printNewLine();
					}
				} else if (!wasACase) {

		}
		this.scribe.printNewLine();
		this.scribe.printNextToken(TerminalTokens.TokenNameRBRACE);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		if (switch_brace.equals(DefaultCodeFormatterConstants.NEXT_LINE_SHIFTED)) {
			this.scribe.unIndent();
		}

		 * Print the semi-colon
		 */
		this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
		this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
		return false;
	}


				action.traverse(this, scope);
				if (action instanceof Expression) {
					this.scribe.printNextToken(TerminalTokens.TokenNameSEMICOLON, this.preferences.insert_space_before_semicolon);
					this.scribe.printComment(CodeFormatter.K_UNKNOWN, Scribe.BASIC_TRAILING_COMMENT);
				}
				this.scribe.unIndent();
			}

Lines 96-103 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/Scribe.java (-197 / +125 lines)
96	public int numberOfIndentations;	96	public int numberOfIndentations;
97	private boolean useTabsOnlyForLeadingIndents;	97	private boolean useTabsOnlyForLeadingIndents;
98		98
99	/** indent empty lines*/	99	/** empty lines*/
100	private final boolean indentEmptyLines;	100	private final boolean indentEmptyLines;
		101	int blank_lines_between_import_groups = -1;
101		102
102	/* Comments formatting */	103	/* Comments formatting */
103	private static final int INCLUDE_BLOCK_COMMENTS = CodeFormatter.F_INCLUDE_COMMENTS \| CodeFormatter.K_MULTI_LINE_COMMENT;	104	private static final int INCLUDE_BLOCK_COMMENTS = CodeFormatter.F_INCLUDE_COMMENTS \| CodeFormatter.K_MULTI_LINE_COMMENT;
Lines 105-110 Link Here
105	private static final int INCLUDE_LINE_COMMENTS = CodeFormatter.F_INCLUDE_COMMENTS \| CodeFormatter.K_SINGLE_LINE_COMMENT;	106	private static final int INCLUDE_LINE_COMMENTS = CodeFormatter.F_INCLUDE_COMMENTS \| CodeFormatter.K_SINGLE_LINE_COMMENT;
106	private static final int SKIP_FIRST_WHITESPACE_TOKEN = -2;	107	private static final int SKIP_FIRST_WHITESPACE_TOKEN = -2;
107	private static final int INVALID_TOKEN = 2000;	108	private static final int INVALID_TOKEN = 2000;
		109	static final int NO_TRAILING_COMMENT = 0;
		110	static final int BASIC_TRAILING_COMMENT = 1;
		111	static final int IMPORT_TRAILING_COMMENT = 2;
108	private int formatComments = 0;	112	private int formatComments = 0;
109	private int headerEndPosition = -1;	113	private int headerEndPosition = -1;
110	String commentIndentation; // indentation requested in comments (usually in javadoc root tags description)	114	String commentIndentation; // indentation requested in comments (usually in javadoc root tags description)
Lines 1065-1070 Link Here
1065	}	1069	}
1066	return Util.EMPTY_STRING;	1070	return Util.EMPTY_STRING;
1067	}	1071	}
		1072	if (this.blank_lines_between_import_groups >= 0) {
		1073	return getEmptyLines(this.blank_lines_between_import_groups);
		1074	}
1068	if (this.formatter.preferences.number_of_empty_lines_to_preserve != 0) {	1075	if (this.formatter.preferences.number_of_empty_lines_to_preserve != 0) {
1069	int linesToPreserve = Math.min(count, this.formatter.preferences.number_of_empty_lines_to_preserve);	1076	int linesToPreserve = Math.min(count, this.formatter.preferences.number_of_empty_lines_to_preserve);
1070	return getEmptyLines(linesToPreserve);	1077	return getEmptyLines(linesToPreserve);
Lines 1310-1318 Link Here
1310		1317
1311	private void preserveEmptyLines(int count, int insertPosition) {	1318	private void preserveEmptyLines(int count, int insertPosition) {
1312	if (count > 0) {	1319	if (count > 0) {
1313	if (this.formatter.preferences.number_of_empty_lines_to_preserve != 0) {	1320	if (this.blank_lines_between_import_groups >= 0) {
		1321	printEmptyLines(this.blank_lines_between_import_groups, insertPosition);
		1322	} else if (this.formatter.preferences.number_of_empty_lines_to_preserve != 0) {
1314	int linesToPreserve = Math.min(count, this.formatter.preferences.number_of_empty_lines_to_preserve);	1323	int linesToPreserve = Math.min(count, this.formatter.preferences.number_of_empty_lines_to_preserve);
1315	this.printEmptyLines(linesToPreserve, insertPosition);	1324	printEmptyLines(linesToPreserve, insertPosition);
1316	} else {	1325	} else {
1317	printNewLine(insertPosition);	1326	printNewLine(insertPosition);
1318	}	1327	}
Lines 2052-2064 Link Here
2052	}	2061	}
2053		2062
2054	void printComment() {	2063	void printComment() {
2055	printComment(CodeFormatter.K_UNKNOWN);	2064	printComment(CodeFormatter.K_UNKNOWN, NO_TRAILING_COMMENT);
2056	}	2065	}
2057		2066
2058	/*	2067	/*
2059	* Main method to print and format comments (javadoc, block and single line comments)	2068	* Main method to print and format comments (javadoc, block and single line comments)
2060	*/	2069	*/
2061	void printComment(int kind) {	2070	void printComment(int kind, int trailing) {
2062	final boolean rejectLineComment = kind == CodeFormatter.K_MULTI_LINE_COMMENT \|\| kind == CodeFormatter.K_JAVA_DOC;	2071	final boolean rejectLineComment = kind == CodeFormatter.K_MULTI_LINE_COMMENT \|\| kind == CodeFormatter.K_JAVA_DOC;
2063	final boolean rejectBlockComment = kind == CodeFormatter.K_SINGLE_LINE_COMMENT \|\| kind == CodeFormatter.K_JAVA_DOC;	2072	final boolean rejectBlockComment = kind == CodeFormatter.K_SINGLE_LINE_COMMENT \|\| kind == CodeFormatter.K_JAVA_DOC;
2064	final boolean rejectJavadocComment = kind == CodeFormatter.K_SINGLE_LINE_COMMENT \|\| kind == CodeFormatter.K_MULTI_LINE_COMMENT;	2073	final boolean rejectJavadocComment = kind == CodeFormatter.K_SINGLE_LINE_COMMENT \|\| kind == CodeFormatter.K_MULTI_LINE_COMMENT;
Lines 2067-2079 Link Here
2067	int currentTokenStartPosition = this.scanner.currentPosition;	2076	int currentTokenStartPosition = this.scanner.currentPosition;
2068	boolean hasComment = false;	2077	boolean hasComment = false;
2069	boolean hasLineComment = false;	2078	boolean hasLineComment = false;
2070	boolean hasWhitespace = false;	2079	boolean hasWhitespaces = false;
2071	int count = 0;	2080	int lines = 0;
2072	while ((this.currentToken = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {	2081	while ((this.currentToken = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
2073	switch(this.currentToken) {	2082	switch(this.currentToken) {
2074	case TerminalTokens.TokenNameWHITESPACE :	2083	case TerminalTokens.TokenNameWHITESPACE :
2075	char[] whiteSpaces = this.scanner.getCurrentTokenSource();	2084	char[] whiteSpaces = this.scanner.getCurrentTokenSource();
2076	count = 0;	2085	int whitespacesStartPosition = this.scanner.getCurrentTokenStartPosition();
		2086	int whitespacesEndPosition = this.scanner.getCurrentTokenEndPosition();
		2087	lines = 0;
2077	for (int i = 0, max = whiteSpaces.length; i < max; i++) {	2088	for (int i = 0, max = whiteSpaces.length; i < max; i++) {
2078	switch(whiteSpaces[i]) {	2089	switch(whiteSpaces[i]) {
2079	case '\r' :	2090	case '\r' :
Lines 2082-2160 Link Here
2082	i++;	2093	i++;
2083	}	2094	}
2084	}	2095	}
2085	count++;	2096	lines++;
2086	break;	2097	break;
2087	case '\n' :	2098	case '\n' :
2088	count++;	2099	lines++;
2089	}	2100	}
2090	}	2101	}
2091	if (count == 0) {	2102	// If following token is a line comment on the same line or the line just after,
2092	hasWhitespace = true;	2103	// then it might be not really formatted as a trailing comment
2093	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());	2104	boolean realTrailing = trailing > NO_TRAILING_COMMENT;
2094	} else if (hasLineComment) {	2105	if (trailing == IMPORT_TRAILING_COMMENT && this.scanner.currentCharacter == '/' && lines <= 1) {
2095	preserveEmptyLines(count, this.scanner.getCurrentTokenStartPosition());	2106	int currentPosition = this.scanner.currentPosition;
2096	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());	2107	if (this.scanner.getNextToken() == TerminalTokens.TokenNameCOMMENT_LINE) {
2097	} else if (hasComment) {	2108	int token = this.scanner.getNextToken();
2098	if (count == 1) {	2109	while (token == TerminalTokens.TokenNameCOMMENT_LINE) {
2099	this.printNewLine(this.scanner.getCurrentTokenStartPosition());	2110	token = this.scanner.getNextToken();
2100	} else {	2111	}
2101	preserveEmptyLines(count - 1, this.scanner.getCurrentTokenStartPosition());	2112	if (token == TerminalTokens.TokenNameWHITESPACE) {
		2113	char[] secondWhiteSpaces = this.scanner.getCurrentTokenSource();
		2114	loop: for (int i = 0, max = secondWhiteSpaces.length; i < max; i++) {
		2115	switch(secondWhiteSpaces[i]) {
		2116	case '\r' :
		2117	case '\n' :
		2118	realTrailing = false;
		2119	break loop;
		2120	}
		2121	}
		2122	}
2102	}	2123	}
2103	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());	2124	this.scanner.resetTo(currentPosition, this.scanner.eofPosition - 1);
2104	} else if (count != 0 && (!this.formatter.preferences.join_wrapped_lines \|\| this.formatter.preferences.number_of_empty_lines_to_preserve != 0)) {	2125	}
2105	addReplaceEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition(), getPreserveEmptyLines(count-1));	2126	if (realTrailing) {
		2127	// if a line comment is consumed, no other comment can be on the same line after
		2128	if (hasLineComment) {
		2129	if (lines >= 1) {
		2130	currentTokenStartPosition = whitespacesStartPosition;
		2131	preserveEmptyLines(lines, currentTokenStartPosition);
		2132	addDeleteEdit(currentTokenStartPosition, whitespacesEndPosition);
		2133	this.scanner.resetTo(this.scanner.currentPosition, this.scannerEndPosition - 1);
		2134	return;
		2135	}
		2136	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
		2137	return;
		2138	}
		2139	// if one or several new lines are consumed, following comments cannot be considered as trailing ones
		2140	if (lines >= 1) {
		2141	if (hasComment) {
		2142	this.printNewLine(whitespacesStartPosition);
		2143	}
		2144	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
		2145	return;
		2146	}
		2147	// delete consumed white spaces
		2148	hasWhitespaces = true;
		2149	currentTokenStartPosition = this.scanner.currentPosition;
		2150	addDeleteEdit(whitespacesStartPosition, whitespacesEndPosition);
2106	} else {	2151	} else {
2107	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());	2152	if (lines == 0) {
		2153	hasWhitespaces = true;
		2154	addDeleteEdit(whitespacesStartPosition, whitespacesEndPosition);
		2155	} else if (hasLineComment) {
		2156	currentTokenStartPosition = whitespacesStartPosition;
		2157	preserveEmptyLines(lines, currentTokenStartPosition);
		2158	addDeleteEdit(currentTokenStartPosition, whitespacesEndPosition);
		2159	} else if (hasComment) {
		2160	if (lines == 1) {
		2161	this.printNewLine(whitespacesStartPosition);
		2162	} else {
		2163	preserveEmptyLines(lines - 1, whitespacesStartPosition);
		2164	}
		2165	addDeleteEdit(whitespacesStartPosition, whitespacesEndPosition);
		2166	} else if (lines != 0 && (!this.formatter.preferences.join_wrapped_lines \|\| this.formatter.preferences.number_of_empty_lines_to_preserve != 0)) {
		2167	addReplaceEdit(whitespacesStartPosition, whitespacesEndPosition, getPreserveEmptyLines(lines-1));
		2168	} else {
		2169	addDeleteEdit(whitespacesStartPosition, whitespacesEndPosition);
		2170	}
2108	}	2171	}
2109	currentTokenStartPosition = this.scanner.currentPosition;	2172	currentTokenStartPosition = this.scanner.currentPosition;
2110	break;	2173	break;
2111	case TerminalTokens.TokenNameCOMMENT_LINE :	2174	case TerminalTokens.TokenNameCOMMENT_LINE :
2112	if (rejectLineComment) break;	2175	if (rejectLineComment) break;
2113	if (count >= 1) {	2176	if (lines >= 1) {
2114	if (count > 1) {	2177	if (lines > 1) {
2115	preserveEmptyLines(count - 1, this.scanner.getCurrentTokenStartPosition());	2178	preserveEmptyLines(lines - 1, this.scanner.getCurrentTokenStartPosition());
2116	} else if (count == 1) {	2179	} else if (lines == 1) {
2117	printNewLine(this.scanner.getCurrentTokenStartPosition());	2180	printNewLine(this.scanner.getCurrentTokenStartPosition());
2118	}	2181	}
2119	} else if (hasWhitespace) {	2182	} else if (hasWhitespaces) {
2120	space();	2183	space();
2121	}	2184	}
2122	hasWhitespace = false;	2185	hasWhitespaces = false;
2123	printLineComment();	2186	printLineComment();
2124	currentTokenStartPosition = this.scanner.currentPosition;	2187	currentTokenStartPosition = this.scanner.currentPosition;
2125	hasLineComment = true;	2188	hasLineComment = true;
2126	count = 0;	2189	lines = 0;
2127	break;	2190	break;
2128	case TerminalTokens.TokenNameCOMMENT_BLOCK :	2191	case TerminalTokens.TokenNameCOMMENT_BLOCK :
		2192	if (trailing > NO_TRAILING_COMMENT && lines >= 1) {
		2193	// a block comment on next line means that there's no trailing comment
		2194	this.scanner.resetTo(this.scanner.getCurrentTokenStartPosition(), this.scannerEndPosition - 1);
		2195	return;
		2196	}
2129	if (rejectBlockComment) break;	2197	if (rejectBlockComment) break;
2130	if (count >= 1) {	2198	if (lines >= 1) {
2131	if (count > 1) {	2199	if (lines > 1) {
2132	preserveEmptyLines(count - 1, this.scanner.getCurrentTokenStartPosition());	2200	preserveEmptyLines(lines - 1, this.scanner.getCurrentTokenStartPosition());
2133	} else if (count == 1) {	2201	} else if (lines == 1) {
2134	printNewLine(this.scanner.getCurrentTokenStartPosition());	2202	printNewLine(this.scanner.getCurrentTokenStartPosition());
2135	}	2203	}
2136	} else if (hasWhitespace) {	2204	} else if (hasWhitespaces) {
2137	space();	2205	space();
2138	}	2206	}
2139	hasWhitespace = false;	2207	hasWhitespaces = false;
2140	printBlockComment(false);	2208	printBlockComment(false);
2141	currentTokenStartPosition = this.scanner.currentPosition;	2209	currentTokenStartPosition = this.scanner.currentPosition;
2142	hasLineComment = false;	2210	hasLineComment = false;
2143	hasComment = true;	2211	hasComment = true;
2144	count = 0;	2212	lines = 0;
2145	break;	2213	break;
2146	case TerminalTokens.TokenNameCOMMENT_JAVADOC :	2214	case TerminalTokens.TokenNameCOMMENT_JAVADOC :
		2215	if (trailing > NO_TRAILING_COMMENT) {
		2216	// a javadoc comment should not be considered as a trailing comment
		2217	this.scanner.resetTo(this.scanner.getCurrentTokenStartPosition(), this.scannerEndPosition - 1);
		2218	return;
		2219	}
2147	if (rejectJavadocComment) break;	2220	if (rejectJavadocComment) break;
2148	if (count >= 1) {	2221	if (lines >= 1) {
2149	if (count > 1) {	2222	if (lines > 1) {
2150	preserveEmptyLines(count - 1, this.scanner.getCurrentTokenStartPosition());	2223	preserveEmptyLines(lines - 1, this.scanner.getCurrentTokenStartPosition());
2151	} else if (count == 1) {	2224	} else if (lines == 1) {
2152	printNewLine(this.scanner.getCurrentTokenStartPosition());	2225	printNewLine(this.scanner.getCurrentTokenStartPosition());
2153	}	2226	}
2154	} else if (hasWhitespace) {	2227	} else if (hasWhitespaces) {
2155	space();	2228	space();
2156	}	2229	}
2157	hasWhitespace = false;	2230	hasWhitespaces = false;
2158	if (includesJavadocComments()) {	2231	if (includesJavadocComments()) {
2159	printJavadocComment(this.scanner.startPosition, this.scanner.currentPosition);	2232	printJavadocComment(this.scanner.startPosition, this.scanner.currentPosition);
2160	} else {	2233	} else {
Lines 2164-2170 Link Here
2164	currentTokenStartPosition = this.scanner.currentPosition;	2237	currentTokenStartPosition = this.scanner.currentPosition;
2165	hasLineComment = false;	2238	hasLineComment = false;
2166	hasComment = true;	2239	hasComment = true;
2167	count = 0;	2240	lines = 0;
2168	break;	2241	break;
2169	default :	2242	default :
2170	// step back one token	2243	// step back one token
Lines 2196-2205 Link Here
2196	// Print corresponding comment	2269	// Print corresponding comment
2197	switch (kind) {	2270	switch (kind) {
2198	case CodeFormatter.K_SINGLE_LINE_COMMENT:	2271	case CodeFormatter.K_SINGLE_LINE_COMMENT:
2199	printComment(kind);	2272	printComment(kind, NO_TRAILING_COMMENT);
2200	break;	2273	break;
2201	case CodeFormatter.K_MULTI_LINE_COMMENT:	2274	case CodeFormatter.K_MULTI_LINE_COMMENT:
2202	printComment(kind);	2275	printComment(kind, NO_TRAILING_COMMENT);
2203	break;	2276	break;
2204	case CodeFormatter.K_JAVA_DOC:	2277	case CodeFormatter.K_JAVA_DOC:
2205	printJavadocComment(start, end);	2278	printJavadocComment(start, end);
Lines 3898-3904 Link Here
3898	this.formatBrace = true;	3971	this.formatBrace = true;
3899	}	3972	}
3900	try {	3973	try {
3901	printComment(CodeFormatter.K_UNKNOWN);	3974	printComment(CodeFormatter.K_UNKNOWN, NO_TRAILING_COMMENT);
3902	try {	3975	try {
3903	this.currentToken = this.scanner.getNextToken();	3976	this.currentToken = this.scanner.getNextToken();
3904	if (expectedTokenType != this.currentToken) {	3977	if (expectedTokenType != this.currentToken) {
Lines 3924-3930 Link Here
3924	}	3997	}
3925		3998
3926	public void printNextToken(int[] expectedTokenTypes, boolean considerSpaceIfAny){	3999	public void printNextToken(int[] expectedTokenTypes, boolean considerSpaceIfAny){
3927	printComment(CodeFormatter.K_UNKNOWN);	4000	printComment(CodeFormatter.K_UNKNOWN, NO_TRAILING_COMMENT);
3928	try {	4001	try {
3929	this.currentToken = this.scanner.getNextToken();	4002	this.currentToken = this.scanner.getNextToken();
3930	if (Arrays.binarySearch(expectedTokenTypes, this.currentToken) < 0) {	4003	if (Arrays.binarySearch(expectedTokenTypes, this.currentToken) < 0) {
Lines 3948-3954 Link Here
3948	int numberOfIdentifiers = 0;	4021	int numberOfIdentifiers = 0;
3949	try {	4022	try {
3950	do {	4023	do {
3951	printComment(CodeFormatter.K_UNKNOWN);	4024	printComment(CodeFormatter.K_UNKNOWN, NO_TRAILING_COMMENT);
3952	switch(this.currentToken = this.scanner.getNextToken()) {	4025	switch(this.currentToken = this.scanner.getNextToken()) {
3953	case TerminalTokens.TokenNameEOF :	4026	case TerminalTokens.TokenNameEOF :
3954	return;	4027	return;
Lines 3994-4000 Link Here
3994	int currentTokenStartPosition = this.scanner.currentPosition;	4067	int currentTokenStartPosition = this.scanner.currentPosition;
3995	try {	4068	try {
3996	do {	4069	do {
3997	printComment(CodeFormatter.K_UNKNOWN);	4070	printComment(CodeFormatter.K_UNKNOWN, NO_TRAILING_COMMENT);
3998	switch(this.currentToken = this.scanner.getNextToken()) {	4071	switch(this.currentToken = this.scanner.getNextToken()) {
3999	case TerminalTokens.TokenNameEOF :	4072	case TerminalTokens.TokenNameEOF :
4000	return;	4073	return;
Lines 4048-4198 Link Here
4048	}	4121	}
4049	}	4122	}
4050		4123
4051	public void printTrailingComment(int numberOfNewLinesToInsert) {
4052	try {
4053	// if we have a space between two tokens we ensure it will be dumped in the formatted string
4054	int currentTokenStartPosition = this.scanner.currentPosition;
4055	boolean hasWhitespaces = false;
4056	boolean hasLineComment = false;
4057	while ((this.currentToken = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
4058	switch(this.currentToken) {
4059	case TerminalTokens.TokenNameWHITESPACE :
4060	int count = 0;
4061	char[] whiteSpaces = this.scanner.getCurrentTokenSource();
4062	for (int i = 0, max = whiteSpaces.length; i < max; i++) {
4063	switch(whiteSpaces[i]) {
4064	case '\r' :
4065	if ((i + 1) < max) {
4066	if (whiteSpaces[i + 1] == '\n') {
4067	i++;
4068	}
4069	}
4070	count++;
4071	break;
4072	case '\n' :
4073	count++;
4074	}
4075	}
4076	if (hasLineComment) {
4077	if (count >= 1) {
4078	currentTokenStartPosition = this.scanner.getCurrentTokenStartPosition();
4079	preserveEmptyLines(numberOfNewLinesToInsert, currentTokenStartPosition);
4080	addDeleteEdit(currentTokenStartPosition, this.scanner.getCurrentTokenEndPosition());
4081	this.scanner.resetTo(this.scanner.currentPosition, this.scannerEndPosition - 1);
4082	return;
4083	}
4084	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4085	return;
4086	} else if (count > 1) {
4087	this.printEmptyLines(numberOfNewLinesToInsert, this.scanner.getCurrentTokenStartPosition());
4088	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4089	return;
4090	} else {
4091	hasWhitespaces = true;
4092	currentTokenStartPosition = this.scanner.currentPosition;
4093	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());
4094	}
4095	break;
4096	case TerminalTokens.TokenNameCOMMENT_LINE :
4097	if (hasWhitespaces) {
4098	space();
4099	}
4100	printLineComment();
4101	currentTokenStartPosition = this.scanner.currentPosition;
4102	hasLineComment = true;
4103	break;
4104	case TerminalTokens.TokenNameCOMMENT_BLOCK :
4105	if (hasWhitespaces) {
4106	space();
4107	}
4108	printBlockComment(false);
4109	currentTokenStartPosition = this.scanner.currentPosition;
4110	break;
4111	default :
4112	// step back one token
4113	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4114	return;
4115	}
4116	}
4117	} catch (InvalidInputException e) {
4118	throw new AbortFormatting(e);
4119	}
4120	}
4121	public void printTrailingComment() {
4122	try {
4123	// if we have a space between two tokens we ensure it will be dumped in the formatted string
4124	int currentTokenStartPosition = this.scanner.currentPosition;
4125	boolean hasWhitespaces = false;
4126	boolean hasComment = false;
4127	boolean hasLineComment = false;
4128	while ((this.currentToken = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
4129	switch(this.currentToken) {
4130	case TerminalTokens.TokenNameWHITESPACE :
4131	int count = 0;
4132	char[] whiteSpaces = this.scanner.getCurrentTokenSource();
4133	for (int i = 0, max = whiteSpaces.length; i < max; i++) {
4134	switch(whiteSpaces[i]) {
4135	case '\r' :
4136	if ((i + 1) < max) {
4137	if (whiteSpaces[i + 1] == '\n') {
4138	i++;
4139	}
4140	}
4141	count++;
4142	break;
4143	case '\n' :
4144	count++;
4145	}
4146	}
4147	if (hasLineComment) {
4148	if (count >= 1) {
4149	currentTokenStartPosition = this.scanner.getCurrentTokenStartPosition();
4150	preserveEmptyLines(count, currentTokenStartPosition);
4151	addDeleteEdit(currentTokenStartPosition, this.scanner.getCurrentTokenEndPosition());
4152	this.scanner.resetTo(this.scanner.currentPosition, this.scannerEndPosition - 1);
4153	return;
4154	}
4155	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4156	return;
4157	} else if (count >= 1) {
4158	if (hasComment) {
4159	this.printNewLine(this.scanner.getCurrentTokenStartPosition());
4160	}
4161	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4162	return;
4163	} else {
4164	hasWhitespaces = true;
4165	currentTokenStartPosition = this.scanner.currentPosition;
4166	addDeleteEdit(this.scanner.getCurrentTokenStartPosition(), this.scanner.getCurrentTokenEndPosition());
4167	}
4168	break;
4169	case TerminalTokens.TokenNameCOMMENT_LINE :
4170	if (hasWhitespaces) {
4171	space();
4172	}
4173	printLineComment();
4174	currentTokenStartPosition = this.scanner.currentPosition;
4175	hasLineComment = true;
4176	break;
4177	case TerminalTokens.TokenNameCOMMENT_BLOCK :
4178	if (hasWhitespaces) {
4179	space();
4180	}
4181	printBlockComment(false);
4182	currentTokenStartPosition = this.scanner.currentPosition;
4183	hasComment = true;
4184	break;
4185	default :
4186	// step back one token
4187	this.scanner.resetTo(currentTokenStartPosition, this.scannerEndPosition - 1);
4188	return;
4189	}
4190	}
4191	} catch (InvalidInputException e) {
4192	throw new AbortFormatting(e);
4193	}
4194	}
4195
4196	void redoAlignment(AlignmentException e){	4124	void redoAlignment(AlignmentException e){
4197	if (e.relativeDepth > 0) { // if exception targets a distinct context	4125	if (e.relativeDepth > 0) { // if exception targets a distinct context
4198	e.relativeDepth--; // record fact that current context got traversed	4126	e.relativeDepth--; // record fact that current context got traversed




}

/**
 * @bug 199265: [formatter] 3.3 Code Formatter mis-places commented-out import statements
 * @test Ensure that the formatter keep commented import declarations on their lines
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=199265"
 */
public void testBug199265a() throws JavaModelException {
	String source =
		"import java.util.List;\n" + 
		"//import java.util.HashMap;\n" + 
		"import java.util.Set;\n" + 
		"\n" + 
		"public class X01 {\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265b() throws JavaModelException {
	String source =
		"import java.util.List;\n" + 
		"import java.util.Set;\n" + 
		"//import java.util.HashMap;\n" + 
		"\n" + 
		"public class X02 {\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265c1() throws JavaModelException {
	String source =
		"import java.util.List;\n" + 
		"//            CU         snippet\n" + 
		"public class X03 {\n" + 
		"	List field;\n" + 
		"}\n";
	formatSource(source,
		"import java.util.List;\n" + 
		"\n" + 
		"//            CU         snippet\n" + 
		"public class X03 {\n" + 
		"	List field;\n" + 
		"}\n"
	);
}
public void testBug199265c2() throws JavaModelException {
	this.formatterPrefs.comment_format_header = true;
	String source =
		"import java.util.List;\n" + 
		"//            CU         snippet\n" + 
		"public class X03 {\n" + 
		"	List field;\n" + 
		"}\n";
	formatSource(source,
		"import java.util.List;\n" + 
		"\n" + 
		"// CU snippet\n" + 
		"public class X03 {\n" + 
		"	List field;\n" + 
		"}\n"
	);
}
public void testBug199265c3() throws JavaModelException {
	String source =
		"import java.util.List;\n" + 
		"\n" + 
		"// line comment\n" + 
		"public class X03 {\n" + 
		"	List field;\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265_wksp1a() throws JavaModelException {
	String source =
		"package wksp1;\n" + 
		"\n" + 
		"import java.util.*;\n" + 
		"import java.util.List; // line comment\n" + 
		"\n" + 
		"/**\n" + 
		" * Javadoc comment\n" + 
		" */\n" + 
		"public class X01 {\n" + 
		"\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265_wksp1b() throws JavaModelException {
	String source =
		"package wksp1;\n" + 
		"\n" + 
		"import java.util.Map;\n" + 
		"\n" + 
		"//==========================\n" + 
		"// Line comment\n" + 
		"//==========================\n" + 
		"\n" + 
		"/**\n" + 
		" * Javadoc comment\n" + 
		" */\n" + 
		"public class X02 {\n" + 
		"\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265_wksp2a() throws JavaModelException {
	String source =
		"package wksp2;\n" + 
		"\n" + 
		"import java.util.Map;\n" + 
		"\n" + 
		"//#if defined(TEST)\n" + 
		"import java.util.Vector;\n" + 
		"//#else\n" + 
		"//##import java.util.Set;\n" + 
		"//#endif\n" + 
		"\n" + 
		"public class X01 {\n" + 
		"\n" + 
		"}\n";
	formatSource(source);
}
public void testBug199265_wksp3a() throws JavaModelException {
	String source =
		"package wksp3;\n" + 
		"\n" + 
		"import java.util.Set;	// comment 1\n" + 
		"import java.util.Map;	// comment 2\n" + 
		"import java.util.List;	// comment 3\n" + 
		"\n" + 
		"public class X01 {\n" + 
		"\n" + 
		"}\n";
	formatSource(source,
		"package wksp3;\n" + 
		"\n" + 
		"import java.util.Set; // comment 1\n" + 
		"import java.util.Map; // comment 2\n" + 
		"import java.util.List; // comment 3\n" + 
		"\n" + 
		"public class X01 {\n" + 
		"\n" + 
		"}\n"
	);
}

/**
 * @bug 208541: [formatter] Formatter does not format whole region/selection
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541"
 */




import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.URL;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.jdt.internal.formatter.DefaultCodeFormatter;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.text.edits.TextEdit;

import com.ibm.icu.util.StringTokenizer;

/**

	private final static File INPUT_DIR = new File(System.getProperty("inputDir"));
	private static File OUTPUT_DIR; // use static to minimize data consumption
	private static File WRITE_DIR;
	
	// Files
	final static String FILES_FILTER = System.getProperty("filesFilter");
	final static int FILES_FILTER_KIND;
	static {
		int kind = 0; // No filter
		if (FILES_FILTER != null) {
			int length = FILES_FILTER.length();
			int idxQM = FILES_FILTER.indexOf('?');
			int idxS = FILES_FILTER.indexOf('*');
			if (idxQM >= 0 && idxS >= 0) {
				kind = 4; // Pure pattern match
			} else if (idxQM >= 0) {
				while (idxQM < length && FILES_FILTER.charAt(idxQM) == '?') {
					idxQM++;
				}
				if (idxQM == length) {
					kind = 3; // Starts with + same length
				} else {
					kind = 4; // Pure pattern match
				}
			} else if (idxS >= 0) {
				while (idxS < length && FILES_FILTER.charAt(idxQM) == '*') {
					idxS++;
				}
				if (idxS == length) {
					kind = 2; // Starts with
				} else {
					kind = 4; // Pure pattern match
				}
			} else {
				kind = 1; // Equals
			}
		}
		FILES_FILTER_KIND = kind;
	}

	// Log
	private static File LOG_FILE;
	private static PrintStream LOG_STREAM;


	private static int MAX_FILES, MAX_DIGITS;

	// Formatting behavior
	final static int FORMAT_REPEAT  = Integer.parseInt(System.getProperty("repeat", "2"));
	private final static boolean NO_COMMENTS = System.getProperty("no_comments", "false").equals("true");
	private static String JOIN_LINES = System.getProperty("join_lines", null);
	private static String BRACES = System.getProperty("braces", null);
	
	// Time measuring
	static class TimeMeasuring {
		long[] formatting = new long[FORMAT_REPEAT];
		int [] occurences = new int[FORMAT_REPEAT];
		int [] null_output = new int[FORMAT_REPEAT];
	}
	private static TimeMeasuring TIME_MEASURES = new TimeMeasuring();
	private static final int ONE_MINUTE = 60000;
	private static final long ONE_HOUR = 3600000L;

	// Failures management
	int failureIndex;

	private static String ECLIPSE_VERSION;
	private static String ECLIPSE_MILESTONE;
	private static String JDT_CORE_VERSION;
	private static String PATCH_BUG, PATCH_VERSION;
	private static boolean JDT_CORE_HEAD;
	private final static IPath[] EXPECTED_FAILURES = INPUT_DIR.getPath().indexOf("v34") < 0
		? new IPath[] {

		// Get files from input dir
		FileFilter filter = new FileFilter() {
			public boolean accept(File pathname) {
				String path = pathname.getPath();
				boolean accept = pathname.isDirectory() || path.endsWith(".java");
				if (accept) {
					switch (FILES_FILTER_KIND) {
						case 1: // Equals
							accept = path.equals(FILES_FILTER);
							break;
						case 2: // Starts with
							accept = path.startsWith(FILES_FILTER);
							break;
						case 3: // Starts with + same length
							accept = path.startsWith(FILES_FILTER) && path.length() == FILES_FILTER.length();
							break;
						case 4: // Pattern
							accept = path.matches(FILES_FILTER);
							break;
					}
				}
				return accept;
            }
		};
		File[] allFiles = ModelTestsUtil.getAllFiles(INPUT_DIR, filter);


		// Init directories
		boolean clean = initDirectories(buffer);
		buffer.append("Compare vs: ");
		if (CAN_COMPARE) {
			if (clean) {
				buffer.append(JDT_CORE_VERSION);
			} else {
				File versionFile = new File(OUTPUT_DIR, "version.txt");
				if (versionFile.exists()) {
					buffer.append(Util.fileContent(versionFile.getAbsolutePath()));
				} else {
					buffer.append("???");
				}
			}
		} else {
			buffer.append("none");
		}
//		buffer.append(LINE_SEPARATOR);

		// Write logs
		System.out.println(buffer.toString());

				clean = true;
			}
		}
		if (clean) {
			if (PATCH_BUG != null || JDT_CORE_HEAD) {
				throw new RuntimeException("Reference can only be updated using a version (i.e. with a closed buildnotes_jdt-core.html)!");
			}
		} else if (!OUTPUT_DIR.exists()) {
			System.err.println("            WARNING: The output directory "+OUTPUT_DIR+" does not exist...");
			System.err.println("            => NO comparison could be done!");
			CAN_COMPARE = false;

	}

	// Get log dir
	try {
		setLogDir(buffer);
	} catch (CoreException e) {
		e.printStackTrace();
	}

	// Get write dir
	String wdir = System.getProperty("writeDir"); //$NON-NLS-1$

	return clean;
}

private static void setLogDir(StringBuffer buffer) throws CoreException {

	// Compute log dir
//	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
//	IProject project = root.getProject("Bugs");
//	IFolder rootFolder = project.getFolder("Formatter");
	File logDir = new File(System.getProperty("logDir"));
	if (!logDir.exists()) {
		return;


	// Compute log sub-directories depending on profiles
	logDir = new File(logDir, ECLIPSE_VERSION);
//	IFolder folder = rootFolder.getFolder(ECLIPSE_VERSION);
//	if (!folder.exists()) folder.create(true, true, null);
	if (PATCH_BUG != null) {
		logDir = new File(logDir, "tests");
		logDir = new File(logDir, PATCH_BUG);
		logDir = new File(logDir, PATCH_VERSION);
//		folder = folder.getFolder("tests");
//		if (!folder.exists()) folder.create(true, true, null);
//		folder = folder.getFolder(PATCH_BUG);
//		if (!folder.exists()) folder.create(true, true, null);
//		folder = folder.getFolder(PATCH_VERSION);
//		if (!folder.exists()) folder.create(true, true, null);
	} else if (JDT_CORE_HEAD) {
		logDir = new File(logDir, "HEAD");
//		folder = folder.getFolder("HEAD");
//		if (!folder.exists()) folder.create(true, true, null);
	} else {
		logDir = new File(logDir, ECLIPSE_MILESTONE);
		logDir = new File(logDir, JDT_CORE_VERSION);
//		folder = folder.getFolder(ECLIPSE_MILESTONE);
//		if (!folder.exists()) folder.create(true, true, null);
//		folder = folder.getFolder(JDT_CORE_VERSION);
//		if (!folder.exists()) folder.create(true, true, null);
	}
	if (NO_COMMENTS || BRACES != null || JOIN_LINES != null) {
		logDir = new File(logDir, "profiles");
//		folder = folder.getFolder("profiles");
//		if (!folder.exists()) folder.create(true, true, null);
		if (JOIN_LINES != null) {
			logDir = new File(new File(logDir, "join_lines"), JOIN_LINES);
//			folder = folder.getFolder("join_lines");
//			if (!folder.exists()) folder.create(true, true, null);
//			folder = folder.getFolder(JOIN_LINES);
//			if (!folder.exists()) folder.create(true, true, null);
		}
		if (NO_COMMENTS) {
			logDir = new File(logDir, "no_comments");
//			folder = folder.getFolder("no_comments");
//			if (!folder.exists()) folder.create(true, true, null);
		}
		if (BRACES != null) {
			logDir = new File(new File(logDir, "braces"), BRACES);
//			folder = folder.getFolder("braces");
//			if (!folder.exists()) folder.create(true, true, null);
//			folder = folder.getFolder(BRACES);
//			if (!folder.exists()) folder.create(true, true, null);
		}
	}
	
	// Create log stream
	logDir.mkdirs();
	String filePrefix = INPUT_DIR.getName().replaceAll("\\.", "");
	String logFileName = filePrefix+".txt";
	LOG_FILE = new File(logDir, logFileName);
	if (LOG_FILE.exists()) {
		File saveDir = new File(logDir, "save");
		saveDir.mkdir();
		int i=0;
		while (true) {
			String newFileName = filePrefix+"_";
			if (i<10) newFileName += "0";
			newFileName += i+".txt";
			File renamedFile = new File(saveDir, newFileName);
			if (LOG_FILE.renameTo(renamedFile)) break;
			i++;
		}
	}
//	LOG_RESOURCE = folder.getFile(logFileName);
	buffer.append("Log file  : ");
	buffer.append(LOG_FILE);
//	buffer.append(LOG_RESOURCE.getFullPath());
	buffer.append(LINE_SEPARATOR);
	try {
		if (LOG_FILE.exists()) {
			Util.delete(LOG_FILE);
		}
		LOG_STREAM = new PrintStream(new BufferedOutputStream(new FileOutputStream(LOG_FILE)));
		LOG_STREAM.flush();
	}
	catch (FileNotFoundException fnfe) {
		System.err.println("Can't create log file"+LOG_FILE); //$NON-NLS-1$
	}
//	if (LOG_RESOURCE.exists()) {
//		Util.delete(LOG_RESOURCE);
//	}
//	LOG_BUFFER = new StringBuffer();
}
private static void setOutputDir(String dir, StringBuffer buffer) {


					patch_line = line;
					StringTokenizer tokenizer = new StringTokenizer(line);
					tokenizer.nextToken(); // 'Patch'
					PATCH_VERSION = tokenizer.nextToken();
					while (tokenizer.hasMoreTokens()) {
						PATCH_BUG = tokenizer.nextToken();
					}

						Integer.parseInt(PATCH_BUG);
					}
					catch (NumberFormatException nfe) {
						System.err.println("Invalid patch bug number noticed in JDT/Core buildnotes: "+PATCH_BUG);
					}
				}
				if (!JDT_CORE_HEAD) break;

	StringBuffer name = new StringBuffer(super.getName());
	if (this.testIndex >= 0) {
		int n = this.testIndex == 0 ? 0 : (int) (Math.log(this.testIndex)/Math.log(10));
		for (int i=n; i<MAX_DIGITS; i++) {
			name.append('0');
		}
		name.append(this.testIndex);

 */
public void tearDownSuite() throws Exception {

	// Display time measures
	StringBuffer buffer1 = new StringBuffer();
	buffer1.append("Time measures:").append(LINE_SEPARATOR);
	buffer1.append("	- first format:").append(LINE_SEPARATOR);
	buffer1.append("		+ elapsed = "+timeString(TIME_MEASURES.formatting[0])).append(LINE_SEPARATOR);
	buffer1.append("		+ occurrences = "+TIME_MEASURES.occurences[0]).append(LINE_SEPARATOR);
	buffer1.append("		+ null output = "+TIME_MEASURES.null_output[0]).append(LINE_SEPARATOR);
	buffer1.append("	- repeated format:").append(LINE_SEPARATOR);
	for (int i=1; i<FORMAT_REPEAT; i++) {
		buffer1.append("	   n° "+(i+1)).append(LINE_SEPARATOR);
		buffer1.append("		+ elapsed = "+timeString(TIME_MEASURES.formatting[i])).append(LINE_SEPARATOR);
		buffer1.append("		+ occurrences = "+TIME_MEASURES.occurences[i]).append(LINE_SEPARATOR);
		buffer1.append("		+ null output = "+TIME_MEASURES.null_output[i]).append(LINE_SEPARATOR);
	}
	buffer1.append(LINE_SEPARATOR);

	// Display stored failures
	StringBuffer buffer = new StringBuffer(LINE_SEPARATOR);
	int max = FAILURES.length;
	for (int i=0; i<max; i++) {
		List failures = FAILURES[i].failures;
		int size = failures.size();
		if (size > 0) {
			buffer1.append(size);
			buffer1.append(" file");
			if (size == 1) {
				buffer1.append(" has ");
			} else {
				buffer1.append("s have ");
			}
			buffer1.append(FAILURES[i]);
			buffer1.append('!');
			buffer1.append(LINE_SEPARATOR);
		}
	}
	buffer1.append(LINE_SEPARATOR);
	StringBuffer buffer2 = new StringBuffer(LINE_SEPARATOR);
	for (int i=0; i<max; i++) {
		List failures = FAILURES[i].failures;
		int size = failures.size();
		if (size > 0) {
			buffer2.append("List of file(s) with ");
			buffer2.append(FAILURES[i]);
			buffer2.append(':');
			buffer2.append(LINE_SEPARATOR);
			for (int j=0; j<size; j++) {
				buffer2.append("	- ");
				buffer2.append(failures.get(j));
				buffer2.append(LINE_SEPARATOR);
			}
		}
	}

	// Log failures
	System.out.println(buffer1.toString());
	if (LOG_STREAM == null) {
		System.out.println(buffer2.toString());
	} else {
		LOG_STREAM.print(buffer1.toString());
		LOG_STREAM.print(buffer2.toString());
		LOG_STREAM.close();
	}
//	LOG_BUFFER.append(buffer1.toString());
//	LOG_BUFFER.append(buffer2.toString());
//	InputStream stream= new InputStream() {
//		private Reader reader= new StringReader(LOG_BUFFER.toString());
//		public int read() throws IOException {
//			return this.reader.read();
//		}
//	};
//	if (LOG_RESOURCE.exists()) {
//		LOG_RESOURCE.setContents(
//			stream,
//			IResource.FORCE | IResource.KEEP_HISTORY,
//			null);
//	} else {
//		LOG_RESOURCE.create(stream, IResource.FORCE, null);
//	}
}

/*

*/

String runFormatter(CodeFormatter codeFormatter, String source, int kind, int indentationLevel, int offset, int length, String lineSeparator, boolean repeat) {
	long timeStart = System.currentTimeMillis();
	TextEdit edit = codeFormatter.format(kind, source, offset, length, indentationLevel, lineSeparator);
	if (FAILURES != null) { // Comparison has started
		TIME_MEASURES.formatting[0] += System.currentTimeMillis() - timeStart;
		TIME_MEASURES.occurences[0]++;
		if (edit == null) TIME_MEASURES.null_output[0]++;
	}
	if (edit == null) {
		this.failureIndex = NO_OUTPUT_FAILURE;
		throw new AssertionFailedError("Formatted source should not be null!");
	}
	String initialResult = org.eclipse.jdt.internal.core.util.Util.editedString(source, edit);

	int count = 0;
	String result = initialResult;
	String previousResult = result;
	while (++count < FORMAT_REPEAT) {
		timeStart = System.currentTimeMillis();
		edit = codeFormatter.format(kind, result, 0, result.length(), indentationLevel, lineSeparator);
		if (FAILURES != null) { // Comparison has started
			TIME_MEASURES.formatting[count] += System.currentTimeMillis() - timeStart;
			TIME_MEASURES.occurences[count]++;
			if (edit == null) TIME_MEASURES.null_output[count]++;
		}
		if (edit == null) return null;
		previousResult = result;
		result = org.eclipse.jdt.internal.core.util.Util.editedString(result, edit);

		assertSourceEquals(counterString+" formatting is different from first one!", previousResult, result);
		*/
		if (!isExpectedFailure()) {
			String counterString = counterToString(count);
			try {
				assertSourceEquals(counterString+" formatting is different from first one!", previousResult, result);
			}

	return initialResult;
}

/**
 * Returns a string to display the given time as a duration
 * formatted as:
 *	<ul>
 *	<li>"XXXms" if the duration is less than 0.1s (e.g. "543ms")</li>
 *	<li>"X.YYs" if the duration is less than 1s (e.g. "5.43s")</li>
 *	<li>"XX.Ys" if the duration is less than 1mn (e.g. "54.3s")</li>
 *	<li>"XXmn XXs" if the duration is less than 1h (e.g. "54mn 3s")</li>
 *	<li>"XXh XXmn XXs" if the duration is over than 1h (e.g. "5h 4mn 3s")</li>
 *	</ul>
 *
 * @param time The time to format as a long.
 * @return The formatted string.
 */
public String timeString(long time) {
	NumberFormat format = NumberFormat.getInstance();
	format.setMaximumFractionDigits(3);
	StringBuffer buffer = new StringBuffer();
	if (time == 0) {
		// print nothing
	} else {
		long h = time / ONE_HOUR;
		if (h > 0) buffer.append(h).append("h "); //$NON-NLS-1$
		long remaining = time % ONE_HOUR;
		long m = remaining / ONE_MINUTE;
		if (h > 0 || m > 0) buffer.append(m).append("mn "); //$NON-NLS-1$
		remaining = remaining % ONE_MINUTE;
		if ((remaining % 1000) == 0) {
			buffer.append(remaining/1000);
		} else {
			buffer.append(format.format(remaining/1000.0));
		}
		buffer.append("s"); //$NON-NLS-1$
	}
	return buffer.toString();
}

/*
 * Test to delete the output directory.
 */

	Util.delete(OUTPUT_DIR);
}


/*
 * Test to fill the output directory with reference.
 */
public void testMakeReferences() throws IOException, Exception {

	// Dump the version
	File versionFile = new Path(OUTPUT_DIR.getPath()).append("version.txt").toFile();
	OUTPUT_DIR.mkdirs();
	Util.writeToFile(JDT_CORE_VERSION, versionFile.getAbsolutePath());

	// Format each file of the input dir and write the result to the output directory
	assertNotNull("We should have got input files from "+INPUT_DIR, this.inputFiles);
	DefaultCodeFormatter codeFormatter = codeFormatter();

Return to bug 199265

Lines 312-317 Link Here

(-)src/org/eclipse/jdt/core/tests/formatter/FormatterBugsTests.java (+142 lines)
312	}	312	}
313		313
314	/**	314	/**
		315	* @bug 199265: [formatter] 3.3 Code Formatter mis-places commented-out import statements
		316	* @test Ensure that the formatter keep commented import declarations on their lines
		317	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=199265"
		318	*/
		319	public void testBug199265a() throws JavaModelException {
		320	String source =
		321	"import java.util.List;\n" +
		322	"//import java.util.HashMap;\n" +
		323	"import java.util.Set;\n" +
		324	"\n" +
		325	"public class X01 {\n" +
		326	"}\n";
		327	formatSource(source);
		328	}
		329	public void testBug199265b() throws JavaModelException {
		330	String source =
		331	"import java.util.List;\n" +
		332	"import java.util.Set;\n" +
		333	"//import java.util.HashMap;\n" +
		334	"\n" +
		335	"public class X02 {\n" +
		336	"}\n";
		337	formatSource(source);
		338	}
		339	public void testBug199265c1() throws JavaModelException {
		340	String source =
		341	"import java.util.List;\n" +
		342	"// CU snippet\n" +
		343	"public class X03 {\n" +
		344	" List field;\n" +
		345	"}\n";
		346	formatSource(source,
		347	"import java.util.List;\n" +
		348	"\n" +
		349	"// CU snippet\n" +
		350	"public class X03 {\n" +
		351	" List field;\n" +
		352	"}\n"
		353	);
		354	}
		355	public void testBug199265c2() throws JavaModelException {
		356	this.formatterPrefs.comment_format_header = true;
		357	String source =
		358	"import java.util.List;\n" +
		359	"// CU snippet\n" +
		360	"public class X03 {\n" +
		361	" List field;\n" +
		362	"}\n";
		363	formatSource(source,
		364	"import java.util.List;\n" +
		365	"\n" +
		366	"// CU snippet\n" +
		367	"public class X03 {\n" +
		368	" List field;\n" +
		369	"}\n"
		370	);
		371	}
		372	public void testBug199265c3() throws JavaModelException {
		373	String source =
		374	"import java.util.List;\n" +
		375	"\n" +
		376	"// line comment\n" +
		377	"public class X03 {\n" +
		378	" List field;\n" +
379	"}\n";
380	formatSource(source);
381	}
382	public void testBug199265_wksp1a() throws JavaModelException {
383	String source =
384	"package wksp1;\n" +
385	"\n" +
386	"import java.util.*;\n" +
387	"import java.util.List; // line comment\n" +
388	"\n" +
389	"/**\n" +
390	" * Javadoc comment\n" +
391	" */\n" +
392	"public class X01 {\n" +
393	"\n" +
394	"}\n";
395	formatSource(source);
396	}
397	public void testBug199265_wksp1b() throws JavaModelException {
398	String source =
399	"package wksp1;\n" +
400	"\n" +
401	"import java.util.Map;\n" +
402	"\n" +
403	"//==========================\n" +
404	"// Line comment\n" +
405	"//==========================\n" +
406	"\n" +
407	"/**\n" +
408	" * Javadoc comment\n" +
409	" */\n" +
410	"public class X02 {\n" +
411	"\n" +
412	"}\n";
413	formatSource(source);
414	}
415	public void testBug199265_wksp2a() throws JavaModelException {
416	String source =
417	"package wksp2;\n" +
418	"\n" +
419	"import java.util.Map;\n" +
420	"\n" +
421	"//#if defined(TEST)\n" +
422	"import java.util.Vector;\n" +
423	"//#else\n" +
424	"//##import java.util.Set;\n" +
425	"//#endif\n" +
426	"\n" +
427	"public class X01 {\n" +
428	"\n" +
429	"}\n";
430	formatSource(source);
431	}
432	public void testBug199265_wksp3a() throws JavaModelException {
433	String source =
434	"package wksp3;\n" +
435	"\n" +
436	"import java.util.Set; // comment 1\n" +
437	"import java.util.Map; // comment 2\n" +
438	"import java.util.List; // comment 3\n" +
439	"\n" +
440	"public class X01 {\n" +
441	"\n" +
442	"}\n";
443	formatSource(source,
444	"package wksp3;\n" +
445	"\n" +
446	"import java.util.Set; // comment 1\n" +
447	"import java.util.Map; // comment 2\n" +
448	"import java.util.List; // comment 3\n" +
449	"\n" +
450	"public class X01 {\n" +
451	"\n" +
452	"}\n"
453	);
454	}
455
456	/**
315	* @bug 208541: [formatter] Formatter does not format whole region/selection	457	* @bug 208541: [formatter] Formatter does not format whole region/selection
316	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541"	458	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=208541"
317	*/	459	*/