Attachment 124662 Details for Bug 246627 – Correct patch

[patch] Correct patch

bug246627_002.txt (text/plain), 35.79 KB, created by David Audel

on 2009-02-04 07:03:45 EST

(hide)

Description:

Filename:

MIME Type:

Creator: David Audel

Created: 2009-02-04 07:03:45 EST

Size: 35.79 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core.tests.model
>Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java,v
>retrieving revision 1.27
>diff -u -r1.27 ASTRewritingStatementsTest.java
>--- src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java	3 Dec 2008 14:36:39 -0000	1.27
>+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java	4 Feb 2009 11:49:48 -0000
>@@ -19,6 +19,7 @@
> 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 {
> 
>@@ -2973,6 +2974,650 @@
> 		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);
>Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java,v
>retrieving revision 1.22
>diff -u -r1.22 ASTRewritingTest.java
>--- src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	27 Jun 2008 16:02:41 -0000	1.22
>+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	4 Feb 2009 11:49:48 -0000
>@@ -71,6 +71,8 @@
> 		IJavaProject proj= createJavaProject("P", new String[] {"src"}, "bin");
> 		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
> 		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
>+		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, DefaultCodeFormatterConstants.TRUE);
>+		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.TRUE);
> 		proj.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
> 		proj.setOption(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
> 		proj.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
>#P org.eclipse.jdt.core
>Index: dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java,v
>retrieving revision 1.59
>diff -u -r1.59 ASTRewriteAnalyzer.java
>--- dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	5 Nov 2008 14:30:17 -0000	1.59
>+++ dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	4 Feb 2009 11:49:51 -0000
>@@ -25,6 +25,7 @@
> import org.eclipse.jdt.core.dom.*;
> import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
> import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;
>+import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
> import org.eclipse.jdt.core.formatter.IndentManipulation;
> import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
> import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;
>@@ -79,6 +80,8 @@
> 	private final LineCommentEndOffsets lineCommentEndOffsets;
> 	
> 	private int beforeRequiredSpaceIndex = -1;
>+	
>+	Map options;
> 
> 	/**
> 	 * Constructor for ASTRewriteAnalyzer.
>@@ -105,6 +108,8 @@
> 
> 		this.extendedSourceRangeComputer = extendedSourceRangeComputer;
> 		this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
>+		
>+		this.options = options;
> 	}
> 
> 	final TokenScanner getScanner() {
>@@ -491,6 +496,7 @@
> 			}
> 
> 			int prevEnd= currPos;
>+			int prevMark= RewriteEvent.UNCHANGED;
> 
> 			final int NONE= 0, NEW= 1, EXISTING= 2;
> 			int separatorState= NEW;
>@@ -509,6 +515,10 @@
> 						separatorState= NEW;
> 					}
> 					if (separatorState == NEW || insertAfterSeparator(node)) {
>+						if (separatorState == EXISTING) {
>+							updateIndent(prevMark, currPos, i, editGroup);
>+						}
>+						
> 						doTextInsert(currPos, node, getNodeIndent(i), true, editGroup); // insert node
> 
> 						separatorState= NEW;
>@@ -534,6 +544,10 @@
> 						currPos= currEnd;
> 						prevEnd= currEnd;
> 					} else {
>+						if (i < lastNonDelete) {
>+							updateIndent(prevMark, currPos, i, editGroup);
>+						}
>+						
> 						// remove element and next separator
> 						int end= getStartOfNextNode(nextIndex, currEnd); // start of next
> 						doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node
>@@ -549,6 +563,9 @@
> 
> 						TextEditGroup editGroup= getEditGroup(currEvent);
> 						ASTNode changed= (ASTNode) currEvent.getNewValue();
>+						
>+						updateIndent(prevMark, currPos, i, editGroup);
>+						
> 						doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);
> 						doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);
> 
>@@ -574,11 +591,15 @@
> 						separatorState= EXISTING;
> 					}
> 				}
>-
>+				
>+				prevMark = currMark;
> 			}
> 			return currPos;
> 		}
>-
>+		
>+		protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
>+			// Do nothing.
>+		}
> 	}
> 
> 	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {
>@@ -794,6 +815,10 @@
> 		}
> 
> 		protected String getSeparatorString(int nodeIndex) {
>+			return getSeparatorString(nodeIndex, nodeIndex + 1);
>+		}
>+		
>+		protected String getSeparatorString(int nodeIndex, int nextNodeIndex) {
> 			int newLines= this.separatorLines == -1 ? getNewLines(nodeIndex) : this.separatorLines;
> 
> 			String lineDelim= getLineDelimiter();
>@@ -801,7 +826,7 @@
> 			for (int i= 0; i < newLines; i++) {
> 				buf.append(lineDelim);
> 			}
>-			buf.append(createIndentString(getNodeIndent(nodeIndex + 1)));
>+			buf.append(createIndentString(getNodeIndent(nextNodeIndex)));
> 			return buf.toString();
> 		}
> 
>@@ -2651,22 +2676,71 @@
> 	}
> 
> 	class SwitchListRewriter extends ParagraphListRewriter {
>+		
>+		private boolean indentSwitchStatementsCompareToCases;
> 
> 		public SwitchListRewriter(int initialIndent) {
> 			super(initialIndent, 0);
>+			this.indentSwitchStatementsCompareToCases = 
>+				DefaultCodeFormatterConstants.TRUE.equals(ASTRewriteAnalyzer.this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES));
> 		}
> 
> 		protected int getNodeIndent(int nodeIndex) {
> 			int indent= getInitialIndent();
>-			ASTNode node= (ASTNode) this.list[nodeIndex].getOriginalValue();
>-			if (node == null) {
>-				node= (ASTNode) this.list[nodeIndex].getNewValue();
>-			}
>-			if (node.getNodeType() != ASTNode.SWITCH_CASE) {
>-				indent++;
>+			
>+			if (this.indentSwitchStatementsCompareToCases) {
>+				RewriteEvent event = this.list[nodeIndex];
>+				int changeKind = event.getChangeKind();
>+				
>+				ASTNode node;
>+				if (changeKind == RewriteEvent.INSERTED || changeKind == RewriteEvent.REPLACED) {
>+					node= (ASTNode)event.getNewValue();
>+				} else {
>+					node= (ASTNode)event.getOriginalValue();
>+				}
>+				
>+				if (node.getNodeType() != ASTNode.SWITCH_CASE) {
>+					indent++;
>+				}
> 			}
> 			return indent;
> 		}
>+		
>+		protected String getSeparatorString(int nodeIndex) {
>+			int total = this.list.length;
>+			
>+			int nextNodeIndex = nodeIndex + 1;
>+			while (nextNodeIndex < total && this.list[nextNodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
>+				nextNodeIndex++;
>+			}
>+			if (nextNodeIndex == total) {
>+				return super.getSeparatorString(nodeIndex);
>+			}
>+			return getSeparatorString(nodeIndex, nextNodeIndex);
>+		}
>+		
>+		protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
>+			if (prevMark != RewriteEvent.UNCHANGED && prevMark != RewriteEvent.REPLACED) return;
>+			
>+			int total = this.list.length;
>+			while (nodeIndex < total && this.list[nodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
>+				nodeIndex++;
>+			}
>+			
>+			int originalIndent = getIndent(originalOffset);
>+			int newIndent = getNodeIndent(nodeIndex);
>+			
>+			if (originalIndent != newIndent) {
>+				
>+				int line= getLineInformation().getLineOfOffset(originalOffset);
>+				if (line >= 0) {
>+					int lineStart= getLineInformation().getLineOffset(line);
>+					
>+					doTextRemove(lineStart, originalOffset - lineStart, editGroup); // remove previous indentation
>+					doTextInsert(lineStart, createIndentString(newIndent), editGroup); // add new indentation
>+				}
>+			}
>+		}
> 	}
> 
> 	/* (non-Javadoc)
>@@ -2683,8 +2757,11 @@
> 		if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {
> 			try {
> 				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
>-				int insertIndent= getIndent(node.getStartPosition()) + 1;
>-
>+				int insertIndent= getIndent(node.getStartPosition());
>+				if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {
>+					insertIndent++;
>+				}
>+				
> 				ParagraphListRewriter listRewriter= new SwitchListRewriter(insertIndent);
> 				StringBuffer leadString= new StringBuffer();
> 				leadString.append(getLineDelimiter());

Actions: View | Diff

Attachments on bug 246627: 124661 | 124662 | 124665