Attachment #124662 for bug #246627




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

public class ASTRewritingStatementsTest extends ASTRewritingTest {


		assertEqualString(preview, buf.toString());

	}
	
	public void testSwitchStatement2() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        }\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("            break;\n");
			buf.append("        case 2:\n");
			buf.append("            i= 2;\n");
			buf.append("            break;\n");
			buf.append("        default:\n");
			buf.append("            i= 3;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 2", blockStatements.size() == 2);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
	
				ASTNode expression= switchStatement.getExpression();
				SimpleName newExpression= ast.newSimpleName("x");
				rewrite.replace(expression, newExpression, null);
	
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 0", statements.size() == 0);
	
				SwitchCase caseStatement1= ast.newSwitchCase();
				caseStatement1.setExpression(ast.newNumberLiteral("1"));
	
				Statement statement1= ast.newReturnStatement();
	
				SwitchCase caseStatement2= ast.newSwitchCase(); // default
				caseStatement2.setExpression(null);
	
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.insertLast(caseStatement1, null);
				listRewrite.insertLast(statement1, null);
				listRewrite.insertLast(caseStatement2, null);
			}
	
			{ // insert, remove, replace statements, change case statements
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(1);
	
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 8", statements.size() == 8);
	
				// remove statements
	
				rewrite.remove((ASTNode) statements.get(0), null);
				rewrite.remove((ASTNode) statements.get(1), null);
				rewrite.remove((ASTNode) statements.get(2), null);
	
				// change case statement
				SwitchCase caseStatement= (SwitchCase) statements.get(3);
				Expression newCaseExpression= ast.newNumberLiteral("10");
				rewrite.replace(caseStatement.getExpression(), newCaseExpression, null);
	
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
	
				{
					// insert case statement
					SwitchCase caseStatement2= ast.newSwitchCase();
					caseStatement2.setExpression(ast.newNumberLiteral("11"));
					listRewrite.insertFirst(caseStatement2, null);
	
					// insert statement
					Statement statement1= ast.newReturnStatement();
					listRewrite.insertAfter(statement1, caseStatement2, null);
				}
	
				{
					// insert case statement
					SwitchCase caseStatement2= ast.newSwitchCase();
					caseStatement2.setExpression(ast.newNumberLiteral("12"));
					listRewrite.insertLast(caseStatement2, null);
	
					// insert statement
					Statement statement1= ast.newReturnStatement();
					listRewrite.insertAfter(statement1, caseStatement2, null);
				}
	
	
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (x) {\n");
			buf.append("        case 1:\n");
			buf.append("            return;\n");
			buf.append("        default:\n");
			buf.append("        }\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 11:\n");
			buf.append("            return;\n");
			buf.append("        case 10:\n");
			buf.append("            i= 2;\n");
			buf.append("            break;\n");
			buf.append("        default:\n");
			buf.append("            i= 3;\n");
			buf.append("        case 12:\n");
			buf.append("            return;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	public void testSwitchStatement3() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 2:\n");
			buf.append("            i= 2;\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 2", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 0", statements.size() == 5);
				
				SwitchCase caseStatement = (SwitchCase)statements.get(2);
	
				BreakStatement breakStatement= ast.newBreakStatement();
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.insertBefore(breakStatement, caseStatement, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("            break;\n");
			buf.append("        case 2:\n");
			buf.append("            i= 2;\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Insert a statement before an unchanged statement (and preceded by an unchanged statement)
	 */
	public void testSwitchStatement5() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				SwitchCase caseStatement = (SwitchCase)statements.get(2); // case 2:
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.insertBefore(ast.newBreakStatement(), caseStatement, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("            break;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Insert a statement after an unchanged statement (and preceded by an unchanged statement)
	 */
	public void testSwitchStatement6() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.insertAfter(ast.newBreakStatement(), assignment, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("            break;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Replace a statement preceded by an unchanged statement)
	 */
	public void testSwitchStatement7() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 3:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
				
				SwitchCase switchCase = ast.newSwitchCase();
				switchCase.setExpression(ast.newNumberLiteral("2"));
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.replace(assignment, switchCase, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("        case 2:\n");
			buf.append("        case 3:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Remove a statement preceded by an unchanged statement)
	 */
	public void testSwitchStatement8() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.remove(assignment, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Remove a statement followed by an inserted statement)
	 */
	public void testSwitchStatement9() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 3:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
			
			AST ast= astRoot.getAST();
	
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;
				
				SwitchCase switchCase = ast.newSwitchCase();
				switchCase.setExpression(ast.newNumberLiteral("2"));
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.remove(assignment, null);
				listRewrite.insertAfter(switchCase, assignment, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("        case 2:\n");
			buf.append("        case 3:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
	 * Remove a statement preceded by an inserted statement)
	 */
	public void testSwitchStatement10() throws Exception {
		String previousValue = null;
		try {
			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
			
			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
			
			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
			StringBuffer buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            i= 1;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
	
			CompilationUnit astRoot= createAST(cu);
			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
			
			AST ast= astRoot.getAST();
			
			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
			Block block= methodDecl.getBody();
			List blockStatements= block.statements();
			assertTrue("Number of statements not 1", blockStatements.size() == 1);
			{ // insert statements, replace expression
				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
				
				List statements= switchStatement.statements();
				assertTrue("Number of statements not 4", statements.size() == 4);
				
				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
				
				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
				listRewrite.insertBefore(ast.newBreakStatement(), assignment, null);
				listRewrite.remove(assignment, null);
			}
	
			String preview= evaluateRewrite(cu, rewrite);
	
			buf= new StringBuffer();
			buf.append("package test1;\n");
			buf.append("public class E {\n");
			buf.append("    public void foo(int i) {\n");
			buf.append("        switch (i) {\n");
			buf.append("        case 1:\n");
			buf.append("            break;\n");
			buf.append("        case 2:\n");
			buf.append("            break;\n");
			buf.append("        }\n");
			buf.append("    }\n");
			buf.append("}\n");
			assertEqualString(preview, buf.toString());
		} finally {
			if (previousValue != null) {
				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
			}
		}
	}

	public void testSynchronizedStatement() throws Exception {
		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);

Lines 71-76 Link Here

(-)src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java (+2 lines)
71	IJavaProject proj= createJavaProject("P", new String[] {"src"}, "bin");	71	IJavaProject proj= createJavaProject("P", new String[] {"src"}, "bin");
72	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);	72	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
73	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");	73	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
		74	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, DefaultCodeFormatterConstants.TRUE);
		75	proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.TRUE);
74	proj.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);	76	proj.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
75	proj.setOption(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);	77	proj.setOption(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
76	proj.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);	78	proj.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);

Lines 25-30 Link Here

(-)dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java (-11 / +88 lines)
25	import org.eclipse.jdt.core.dom.*;	25	import org.eclipse.jdt.core.dom.*;
26	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;	26	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
27	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;	27	import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;
		28	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
28	import org.eclipse.jdt.core.formatter.IndentManipulation;	29	import org.eclipse.jdt.core.formatter.IndentManipulation;
29	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	30	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
30	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;	31	import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;
Lines 79-84 Link Here
79	private final LineCommentEndOffsets lineCommentEndOffsets;	80	private final LineCommentEndOffsets lineCommentEndOffsets;
80		81
81	private int beforeRequiredSpaceIndex = -1;	82	private int beforeRequiredSpaceIndex = -1;
		83
		84	Map options;
82		85
83	/**	86	/**
84	* Constructor for ASTRewriteAnalyzer.	87	* Constructor for ASTRewriteAnalyzer.
Lines 105-110 Link Here
105		108
106	this.extendedSourceRangeComputer = extendedSourceRangeComputer;	109	this.extendedSourceRangeComputer = extendedSourceRangeComputer;
107	this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);	110	this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
		111
		112	this.options = options;
108	}	113	}
109		114
110	final TokenScanner getScanner() {	115	final TokenScanner getScanner() {
Lines 491-496 Link Here
491	}	496	}
492		497
493	int prevEnd= currPos;	498	int prevEnd= currPos;
		499	int prevMark= RewriteEvent.UNCHANGED;
494		500
495	final int NONE= 0, NEW= 1, EXISTING= 2;	501	final int NONE= 0, NEW= 1, EXISTING= 2;
496	int separatorState= NEW;	502	int separatorState= NEW;
Lines 509-514 Link Here
509	separatorState= NEW;	515	separatorState= NEW;
510	}	516	}
511	if (separatorState == NEW \|\| insertAfterSeparator(node)) {	517	if (separatorState == NEW \|\| insertAfterSeparator(node)) {
		518	if (separatorState == EXISTING) {
		519	updateIndent(prevMark, currPos, i, editGroup);
		520	}
		521
512	doTextInsert(currPos, node, getNodeIndent(i), true, editGroup); // insert node	522	doTextInsert(currPos, node, getNodeIndent(i), true, editGroup); // insert node
513		523
514	separatorState= NEW;	524	separatorState= NEW;
Lines 534-539 Link Here
534	currPos= currEnd;	544	currPos= currEnd;
535	prevEnd= currEnd;	545	prevEnd= currEnd;
536	} else {	546	} else {
		547	if (i < lastNonDelete) {
		548	updateIndent(prevMark, currPos, i, editGroup);
		549	}
		550
537	// remove element and next separator	551	// remove element and next separator
538	int end= getStartOfNextNode(nextIndex, currEnd); // start of next	552	int end= getStartOfNextNode(nextIndex, currEnd); // start of next
539	doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node	553	doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node
Lines 549-554 Link Here
549		563
550	TextEditGroup editGroup= getEditGroup(currEvent);	564	TextEditGroup editGroup= getEditGroup(currEvent);
551	ASTNode changed= (ASTNode) currEvent.getNewValue();	565	ASTNode changed= (ASTNode) currEvent.getNewValue();
		566
		567	updateIndent(prevMark, currPos, i, editGroup);
		568
552	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);	569	doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);
553	doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);	570	doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);
554		571
Lines 574-584 Link Here
574	separatorState= EXISTING;	591	separatorState= EXISTING;
575	}	592	}
576	}	593	}
577		594
		595	prevMark = currMark;
578	}	596	}
579	return currPos;	597	return currPos;
580	}	598	}
581		599
		600	protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
		601	// Do nothing.
		602	}
582	}	603	}
583		604
584	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {	605	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {
Lines 794-799 Link Here
794	}	815	}
795		816
796	protected String getSeparatorString(int nodeIndex) {	817	protected String getSeparatorString(int nodeIndex) {
		818	return getSeparatorString(nodeIndex, nodeIndex + 1);
		819	}
		820
		821	protected String getSeparatorString(int nodeIndex, int nextNodeIndex) {
797	int newLines= this.separatorLines == -1 ? getNewLines(nodeIndex) : this.separatorLines;	822	int newLines= this.separatorLines == -1 ? getNewLines(nodeIndex) : this.separatorLines;
798		823
799	String lineDelim= getLineDelimiter();	824	String lineDelim= getLineDelimiter();
Lines 801-807 Link Here
801	for (int i= 0; i < newLines; i++) {	826	for (int i= 0; i < newLines; i++) {
802	buf.append(lineDelim);	827	buf.append(lineDelim);
803	}	828	}
804	buf.append(createIndentString(getNodeIndent(nodeIndex + 1)));	829	buf.append(createIndentString(getNodeIndent(nextNodeIndex)));
805	return buf.toString();	830	return buf.toString();
806	}	831	}
807		832
Lines 2651-2672 Link Here
2651	}	2676	}
2652		2677
2653	class SwitchListRewriter extends ParagraphListRewriter {	2678	class SwitchListRewriter extends ParagraphListRewriter {
		2679
		2680	private boolean indentSwitchStatementsCompareToCases;
2654		2681
2655	public SwitchListRewriter(int initialIndent) {	2682	public SwitchListRewriter(int initialIndent) {
2656	super(initialIndent, 0);	2683	super(initialIndent, 0);
		2684	this.indentSwitchStatementsCompareToCases =
		2685	DefaultCodeFormatterConstants.TRUE.equals(ASTRewriteAnalyzer.this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES));
2657	}	2686	}
2658		2687
2659	protected int getNodeIndent(int nodeIndex) {	2688	protected int getNodeIndent(int nodeIndex) {
2660	int indent= getInitialIndent();	2689	int indent= getInitialIndent();
2661	ASTNode node= (ASTNode) this.list[nodeIndex].getOriginalValue();	2690
2662	if (node == null) {	2691	if (this.indentSwitchStatementsCompareToCases) {
2663	node= (ASTNode) this.list[nodeIndex].getNewValue();	2692	RewriteEvent event = this.list[nodeIndex];
2664	}	2693	int changeKind = event.getChangeKind();
2665	if (node.getNodeType() != ASTNode.SWITCH_CASE) {	2694
2666	indent++;	2695	ASTNode node;
		2696	if (changeKind == RewriteEvent.INSERTED \|\| changeKind == RewriteEvent.REPLACED) {
		2697	node= (ASTNode)event.getNewValue();
		2698	} else {
		2699	node= (ASTNode)event.getOriginalValue();
		2700	}
		2701
		2702	if (node.getNodeType() != ASTNode.SWITCH_CASE) {
		2703	indent++;
		2704	}
2667	}	2705	}
2668	return indent;	2706	return indent;
2669	}	2707	}
		2708
		2709	protected String getSeparatorString(int nodeIndex) {
		2710	int total = this.list.length;
		2711
		2712	int nextNodeIndex = nodeIndex + 1;
		2713	while (nextNodeIndex < total && this.list[nextNodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
		2714	nextNodeIndex++;
		2715	}
		2716	if (nextNodeIndex == total) {
		2717	return super.getSeparatorString(nodeIndex);
		2718	}
		2719	return getSeparatorString(nodeIndex, nextNodeIndex);
		2720	}
		2721
		2722	protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
		2723	if (prevMark != RewriteEvent.UNCHANGED && prevMark != RewriteEvent.REPLACED) return;
		2724
		2725	int total = this.list.length;
		2726	while (nodeIndex < total && this.list[nodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
		2727	nodeIndex++;
		2728	}
		2729
		2730	int originalIndent = getIndent(originalOffset);
		2731	int newIndent = getNodeIndent(nodeIndex);
		2732
		2733	if (originalIndent != newIndent) {
		2734
		2735	int line= getLineInformation().getLineOfOffset(originalOffset);
		2736	if (line >= 0) {
		2737	int lineStart= getLineInformation().getLineOffset(line);
		2738
		2739	doTextRemove(lineStart, originalOffset - lineStart, editGroup); // remove previous indentation
		2740	doTextInsert(lineStart, createIndentString(newIndent), editGroup); // add new indentation
		2741	}
		2742	}
		2743	}
2670	}	2744	}
2671		2745
2672	/* (non-Javadoc)	2746	/* (non-Javadoc)
Lines 2683-2690 Link Here
2683	if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {	2757	if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {
2684	try {	2758	try {
2685	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);	2759	pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
2686	int insertIndent= getIndent(node.getStartPosition()) + 1;	2760	int insertIndent= getIndent(node.getStartPosition());
2687		2761	if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {
		2762	insertIndent++;
		2763	}
		2764
2688	ParagraphListRewriter listRewriter= new SwitchListRewriter(insertIndent);	2765	ParagraphListRewriter listRewriter= new SwitchListRewriter(insertIndent);
2689	StringBuffer leadString= new StringBuffer();	2766	StringBuffer leadString= new StringBuffer();
2690	leadString.append(getLineDelimiter());	2767	leadString.append(getLineDelimiter());

Return to bug 246627