Bug 564059 - [15][dom ast rewrite] JEP 360 - Sealed Types - rewriteY20200801-1200

Change-Id: I74399282f218427cc4b50283724b6ac7b7078b53

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('}');