diff options
author | Sarika Sinha | 2020-07-22 07:01:09 +0000 |
---|---|---|
committer | Sarika Sinha | 2020-07-30 11:00:30 +0000 |
commit | 0acf85c0db3d602786ceeed257a66360361d5787 (patch) | |
tree | 9a218748215ef790277343397fa85833a5a65867 | |
parent | a35cbfb64e6c16bc270351fc4e9f0e3d2fd6be17 (diff) | |
download | eclipse.jdt.core-0acf85c0db3d602786ceeed257a66360361d5787.tar.gz eclipse.jdt.core-0acf85c0db3d602786ceeed257a66360361d5787.tar.xz eclipse.jdt.core-0acf85c0db3d602786ceeed257a66360361d5787.zip |
Bug 564059 - [15][dom ast rewrite] JEP 360 - Sealed Types - rewriteY20200801-1200
Change-Id: I74399282f218427cc4b50283724b6ac7b7078b53
-rw-r--r-- | org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java | 6 | ||||
-rw-r--r-- | org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTypeDeclTest.java | 523 | ||||
-rw-r--r-- | org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite_15Test.java (renamed from org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite14Test.java) | 6 | ||||
-rw-r--r-- | org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java | 14 | ||||
-rw-r--r-- | org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java | 11 |
5 files changed, 551 insertions, 9 deletions
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java index 86f5ce3b38..f60a5a686e 100644 --- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java +++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java @@ -8,6 +8,10 @@ * * SPDX-License-Identifier: EPL-2.0 * + * This is an implementation of an early-draft specification developed under the Java + * Community Process (JCP) and is made available for testing and evaluation purposes + * only. The code is not compatible with any specification of the JCP. + * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ @@ -151,7 +155,7 @@ public class ASTRewritingTest extends AbstractJavaModelTests { suite.addTest(SourceModifierTest.suite()); suite.addTest(ImportRewriteTest.suite()); suite.addTest(ImportRewrite18Test.suite()); - suite.addTest(ImportRewrite14Test.suite()); + suite.addTest(ImportRewrite_15Test.suite()); return suite; } diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTypeDeclTest.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTypeDeclTest.java index 6e0fc5b876..b907f8c3c2 100644 --- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTypeDeclTest.java +++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTypeDeclTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2018 IBM Corporation and others. + * Copyright (c) 2000, 2020 IBM Corporation and others. * * This program and the accompanying materials * are made available under the terms of the Eclipse Public License 2.0 @@ -8,6 +8,10 @@ * * SPDX-License-Identifier: EPL-2.0 * + * This is an implementation of an early-draft specification developed under the Java + * Community Process (JCP) and is made available for testing and evaluation purposes + * only. The code is not compatible with any specification of the JCP. + * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ @@ -15,8 +19,6 @@ package org.eclipse.jdt.core.tests.rewrite.describing; import java.util.List; -import junit.framework.Test; - import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; @@ -33,12 +35,13 @@ import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor; import org.eclipse.jdt.core.dom.ChildPropertyDescriptor; import org.eclipse.jdt.core.dom.ClassInstanceCreation; import org.eclipse.jdt.core.dom.CompilationUnit; +import org.eclipse.jdt.core.dom.Dimension; import org.eclipse.jdt.core.dom.EnumConstantDeclaration; import org.eclipse.jdt.core.dom.EnumDeclaration; import org.eclipse.jdt.core.dom.Expression; import org.eclipse.jdt.core.dom.ExpressionStatement; -import org.eclipse.jdt.core.dom.Dimension; import org.eclipse.jdt.core.dom.FieldDeclaration; +import org.eclipse.jdt.core.dom.ITypeBinding; import org.eclipse.jdt.core.dom.ImportDeclaration; import org.eclipse.jdt.core.dom.MarkerAnnotation; import org.eclipse.jdt.core.dom.MethodDeclaration; @@ -49,6 +52,7 @@ import org.eclipse.jdt.core.dom.ParameterizedType; import org.eclipse.jdt.core.dom.PrimitiveType; import org.eclipse.jdt.core.dom.SimpleName; import org.eclipse.jdt.core.dom.SimplePropertyDescriptor; +import org.eclipse.jdt.core.dom.SimpleType; import org.eclipse.jdt.core.dom.SingleMemberAnnotation; import org.eclipse.jdt.core.dom.SingleVariableDeclaration; import org.eclipse.jdt.core.dom.StringLiteral; @@ -61,7 +65,8 @@ import org.eclipse.jdt.core.dom.WildcardType; import org.eclipse.jdt.core.dom.rewrite.ASTRewrite; import org.eclipse.jdt.core.dom.rewrite.ListRewrite; import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants; -import org.eclipse.jdt.core.dom.ITypeBinding; + +import junit.framework.Test; @SuppressWarnings({"rawtypes", "unchecked"}) public class ASTRewritingTypeDeclTest extends ASTRewritingTest { @@ -2041,4 +2046,512 @@ public class ASTRewritingTypeDeclTest extends ASTRewritingTest { assertEqualString(preview, buf.toString()); } + @SuppressWarnings("deprecation") + private boolean checkAPILevel(int level) { + if (this.apiLevel != level) { + System.err.println("Test "+getName()+" requires a JRE " + level); + return true; + } + return false; + } + + public void testSealedModifier_001() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + + ICompilationUnit cu= pack1.createCompilationUnit("C.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 typeC= findTypeDeclaration(astRoot, "C"); + { // add 1 permits + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C2")); + listRewrite2.insertLast(newPermits, null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1, C2{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + + public void testSealedModifier_002() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1, C2 {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("final class C1 extends C{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null); + + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + CompilationUnit astRoot= createAST(cu); + ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST()); + + assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0); + TypeDeclaration typeC= findTypeDeclaration(astRoot, "C"); + { // remove permits + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + List permittedTypes = typeC.permittedTypes(); + listRewrite2.remove((SimpleType)permittedTypes.get(1), null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1 {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("final class C1 extends C{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + public void testSealedModifier_003() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public class C {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("class C1 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null); + + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + CompilationUnit astRoot= createAST(cu); + ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST()); + + AST ast= astRoot.getAST(); + + assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0); + TypeDeclaration typeC= findTypeDeclaration(astRoot, "C"); + { // add sealed and permits + ListRewrite listRewrite= rewrite.getListRewrite(typeC, TypeDeclaration.MODIFIERS2_PROPERTY); + listRewrite.insertLast(ast.newModifier(Modifier.ModifierKeyword.SEALED_KEYWORD), null); + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C1")); + listRewrite2.insertLast(newPermits, null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1 {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("class C1 extends C{}\n"); + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + public void testSealedModifier_004() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1{}\n"); + buf.append("final class C1 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null); + + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + CompilationUnit astRoot= createAST(cu); + ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST()); + + assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0); + TypeDeclaration typeC= findTypeDeclaration(astRoot, "C"); + { // remove last permit + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + List permittedTypes = typeC.permittedTypes(); + listRewrite2.remove((SimpleType)permittedTypes.get(0), null); + + // remove sealed + ListRewrite listRewrite= rewrite.getListRewrite(typeC, TypeDeclaration.MODIFIERS2_PROPERTY); + List modifiers = typeC.modifiers(); + listRewrite.remove((Modifier)modifiers.get(1), null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public class C{}\n"); + buf.append("final class C1 extends C{}\n"); + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + public void testSealedModifier_005() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + + ICompilationUnit cu= pack1.createCompilationUnit("C.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 typeC= findTypeDeclaration(astRoot, "C"); + { // replace permits + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + List permittedTypes = typeC.permittedTypes(); + listRewrite2.remove((SimpleType)permittedTypes.get(0), null); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C2")); + listRewrite2.insertLast(newPermits, null); + + } + + TypeDeclaration typeC1= findTypeDeclaration(astRoot, "C1"); + { + // remove non-sealed + ListRewrite listRewrite= rewrite.getListRewrite(typeC1, TypeDeclaration.MODIFIERS2_PROPERTY); + List modifiers = typeC1.modifiers(); + listRewrite.remove((Modifier)modifiers.get(0), null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C2{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + public void testSealedModifier_006() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C3{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C3 extends C{}\n"); + buf.append("class C1{\n"); + buf.append("final class C2 extends C{}\n"); + buf.append("}\n"); + + ICompilationUnit cu= pack1.createCompilationUnit("C.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 typeC= findTypeDeclaration(astRoot, "C"); + { // add permits for inner class + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newQualifiedName(ast.newName("C1"), ast.newSimpleName("C2"))); + listRewrite2.insertLast(newPermits, null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C3, C1.C2{\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("non-sealed class C3 extends C{}\n"); + buf.append("class C1{\n"); + buf.append("final class C2 extends C{}\n"); + buf.append("}\n"); + + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + + public void testSealedModifier_007() throws Exception { + + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1 //comment\n"); + buf.append("{\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.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 typeC= findTypeDeclaration(astRoot, "C"); + + { // add 1 more permits + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C2")); + listRewrite2.insertLast(newPermits, null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C permits C1 //comment\n"); + buf.append(", C2\n"); + buf.append("{\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + buf.append("non-sealed class C2 extends C{}\n"); + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + } + + public void testSealedModifier_008() throws Exception { + + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + this.project1.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_15); + this.project1.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_15); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public class C//comment\n"); + buf.append("{\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.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 typeC= findTypeDeclaration(astRoot, "C"); + + { // add 1 permits + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C1")); + listRewrite2.insertLast(newPermits, null); + + } + { // add sealed + ListRewrite listRewrite= rewrite.getListRewrite(typeC, TypeDeclaration.MODIFIERS2_PROPERTY); + listRewrite.insertLast(ast.newModifier(Modifier.ModifierKeyword.SEALED_KEYWORD), null); + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C//comment\n"); + buf.append(" permits C1\n"); + buf.append("{\n"); + buf.append("}\n"); + buf.append("non-sealed class C1 extends C{}\n"); + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + } + + public void testSealedModifier_009() throws Exception { + if (checkAPILevel(15)) { + return; + } + IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null); + StringBuffer buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public class C implements B {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("class C1 extends C{}\n"); + ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null); + + String old = this.project1.getOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, true); + try { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.ENABLED); + this.project1.setOption(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.IGNORE); + CompilationUnit astRoot= createAST(cu); + ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST()); + + AST ast= astRoot.getAST(); + + assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0); + TypeDeclaration typeC= findTypeDeclaration(astRoot, "C"); + { // add sealed and permits + ListRewrite listRewrite= rewrite.getListRewrite(typeC, TypeDeclaration.MODIFIERS2_PROPERTY); + listRewrite.insertLast(ast.newModifier(Modifier.ModifierKeyword.SEALED_KEYWORD), null); + + ListRewrite listRewrite2= rewrite.getListRewrite(typeC, TypeDeclaration.PERMITS_TYPES_PROPERTY); + SimpleType newPermits= ast.newSimpleType(ast.newSimpleName("C1")); + listRewrite2.insertLast(newPermits, null); + + } + + String preview= evaluateRewrite(cu, rewrite); + + buf= new StringBuffer(); + buf.append("package test1;\n"); + buf.append("public sealed class C implements B permits C1 {\n"); + buf.append("\n"); + buf.append("}\n"); + buf.append("class C1 extends C{}\n"); + + assertEqualString(preview, buf.toString()); + }finally { + this.project1.setOption(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, old); + } + + } + } diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite14Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite_15Test.java index 242cd04f11..4e34f6de83 100644 --- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite14Test.java +++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewrite_15Test.java @@ -43,16 +43,16 @@ import junit.framework.Test; @SuppressWarnings("rawtypes") -public class ImportRewrite14Test extends AbstractJavaModelTests { +public class ImportRewrite_15Test extends AbstractJavaModelTests { - private static final Class THIS= ImportRewrite14Test.class; + private static final Class THIS= ImportRewrite_15Test.class; private static final String PROJECT = "ImportRewrite14TestProject"; protected IPackageFragmentRoot sourceFolder; - public ImportRewrite14Test(String name) { + public ImportRewrite_15Test(String name) { super(name); } diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java index 68d7fa8b28..82f284da80 100644 --- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java +++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java @@ -1573,6 +1573,8 @@ public final class ASTRewriteAnalyzer extends ASTVisitor { case TerminalTokens.TokenNamestrictfp: keep= Modifier.isStrictfp(newModifiers); break; case TerminalTokens.TokenNametransient: keep= Modifier.isTransient(newModifiers); break; case TerminalTokens.TokenNamesynchronized: keep= Modifier.isSynchronized(newModifiers); break; + case TerminalTokens.TokenNameRestrictedIdentifiersealed: keep= Modifier.isSealed(newModifiers); break; + case TerminalTokens.TokenNamenon_sealed: keep= Modifier.isNonSealed(newModifiers); break; default: break loop; } @@ -1951,6 +1953,18 @@ public final class ASTRewriteAnalyzer extends ASTVisitor { pos= rewriteNodeList(node, superInterfaceProperty, pos, keyword, ", "); //$NON-NLS-1$ } + if (DOMASTUtil.isFeatureSupportedinAST(node.getAST(), Modifier.SEALED)) { + // permits for sealed + ChildListPropertyDescriptor permitsProperty= TypeDeclaration.PERMITS_TYPES_PROPERTY; + + RewriteEvent permitsEvent= getEvent(node, permitsProperty); + if (permitsEvent == null || permitsEvent.getChangeKind() == RewriteEvent.UNCHANGED) { + pos= doVisit(node, permitsProperty, pos); + } else { + pos= rewriteNodeList(node, permitsProperty, pos, " permits ", ", "); //$NON-NLS-1$ //$NON-NLS-2$ + } + } + // type members // startPos : find position after left brace of type, be aware that bracket might be missing int startIndent= getIndent(node.getStartPosition()) + 1; diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java index d9dec4d146..be8c482058 100644 --- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java +++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFlattener.java @@ -172,6 +172,12 @@ public class ASTRewriteFlattener extends ASTVisitor { if (Modifier.isTransient(modifiers)) { buf.append("transient "); //$NON-NLS-1$ } + if (Modifier.isSealed(modifiers)) { + buf.append("sealed ");//$NON-NLS-1$ + } + if (Modifier.isNonSealed(modifiers)) { + buf.append("non-sealed ");//$NON-NLS-1$ + } } @@ -1142,6 +1148,11 @@ public class ASTRewriteFlattener extends ASTVisitor { ChildListPropertyDescriptor superInterfaceProperty= (apiLevel == JLS2_INTERNAL) ? INTERNAL_TYPE_SUPER_INTERFACES_PROPERTY : TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY; String lead= isInterface ? "extends " : "implements "; //$NON-NLS-1$//$NON-NLS-2$ visitList(node, superInterfaceProperty, String.valueOf(','), lead, Util.EMPTY_STRING); + + + if (DOMASTUtil.isFeatureSupportedinAST(node.getAST(), Modifier.SEALED) && !node.permittedTypes().isEmpty()) { + visitList(node, TypeDeclaration.PERMITS_TYPES_PROPERTY, String.valueOf(','), lead, Util.EMPTY_STRING); + } this.result.append('{'); visitList(node, TypeDeclaration.BODY_DECLARATIONS_PROPERTY, null); this.result.append('}'); |