feature: sealed classes (JEP 409) (#4337)

Co-authored-by: I-Al-Istannen <[email protected]>

Author: SirYwell

spoon-visualisation/src/test/java/spoon/visualisation/instrument/SpoonCodeInstrumentTest.java

@@ -56,6 +56,7 @@
 import spoon.reflect.cu.SourcePositionHolder;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
+import spoon.reflect.declaration.CtSealable;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.path.CtPath;
 import spoon.reflect.visitor.CtVisitable;
@@ -232,7 +233,7 @@ void testSaveText(final FxRobot robot, @TempDir final Path tempDir) throws IOExc
 	@Test
 	void getDirectSpoonInterfacesOfClass() {
 		final List<Class<?>> inter = spoonCodeInstrument.getDirectSpoonInterfaces(CtClass.class).collect(Collectors.toList());
-		assertThat(inter).containsExactlyInAnyOrder(CtType.class, CtStatement.class);
+		assertThat(inter).containsExactlyInAnyOrder(CtType.class, CtStatement.class, CtSealable.class);
 	}
 
 	@Test

src/main/java/spoon/metamodel/Metamodel.java

@@ -152,6 +152,7 @@ public static Set<CtType<?>> getAllMetamodelInterfaces() {
 		result.add(factory.Type().get(spoon.reflect.declaration.CtNamedElement.class));
 		result.add(factory.Type().get(spoon.reflect.declaration.CtPackage.class));
 		result.add(factory.Type().get(spoon.reflect.declaration.CtParameter.class));
+		result.add(factory.Type().get(spoon.reflect.declaration.CtSealable.class));
 		result.add(factory.Type().get(spoon.reflect.declaration.CtShadowable.class));
 		result.add(factory.Type().get(spoon.reflect.declaration.CtType.class));
 		result.add(factory.Type().get(spoon.reflect.declaration.CtTypeInformation.class));

src/main/java/spoon/reflect/declaration/CtClass.java

@@ -31,7 +31,7 @@
  * </pre>
  * @author Renaud Pawlak
  */
-public interface CtClass<T> extends CtType<T>, CtStatement {
+public interface CtClass<T> extends CtType<T>, CtStatement, CtSealable {
 	/**
 	 * Returns the anonymous blocks of this class.
 	 * Derived from {@link #getTypeMembers()}

src/main/java/spoon/reflect/declaration/CtEnum.java

@@ -10,9 +10,12 @@
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.annotations.PropertyGetter;
 import spoon.reflect.annotations.PropertySetter;
+import spoon.support.DerivedProperty;
 import spoon.support.UnsettableProperty;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Set;
 
 import static spoon.reflect.path.CtRole.VALUE;
 
@@ -80,4 +83,20 @@ public interface CtEnum<T extends Enum<?>> extends CtClass<T> {
 	@Override
 	@UnsettableProperty
 	<C extends CtType<T>> C setSuperclass(CtTypeReference<?> superClass);
+
+	@Override
+	@DerivedProperty
+	Set<CtTypeReference<?>> getPermittedTypes();
+
+	@Override
+	@UnsettableProperty
+	CtEnum<T> setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes);
+
+	@Override
+	@UnsettableProperty
+	CtEnum<T> addPermittedType(CtTypeReference<?> type);
+
+	@Override
+	@UnsettableProperty
+	CtEnum<T> removePermittedType(CtTypeReference<?> type);
 }

src/main/java/spoon/reflect/declaration/CtInterface.java

@@ -21,7 +21,7 @@
  *     }
  * </pre>
  */
-public interface CtInterface<T> extends CtType<T>, CtStatement {
+public interface CtInterface<T> extends CtType<T>, CtStatement, CtSealable {
 	@Override
 	CtInterface<T> clone();
 

src/main/java/spoon/reflect/declaration/CtRecord.java

@@ -7,6 +7,7 @@
  */
 package spoon.reflect.declaration;
 
+import java.util.Collection;
 import java.util.Set;
 import spoon.reflect.annotations.PropertyGetter;
 import spoon.reflect.annotations.PropertySetter;
@@ -40,4 +41,19 @@ public interface CtRecord extends CtClass<Object> {
 	@Override
 	@UnsettableProperty
 	<C extends CtType<Object>> C setSuperclass(CtTypeReference<?> superClass);
+
+	@Override
+	Set<CtTypeReference<?>> getPermittedTypes();
+
+	@Override
+	@UnsettableProperty
+	CtRecord setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes);
+
+	@Override
+	@UnsettableProperty
+	CtRecord addPermittedType(CtTypeReference<?> type);
+
+	@Override
+	@UnsettableProperty
+	CtRecord removePermittedType(CtTypeReference<?> type);
 }

src/main/java/spoon/reflect/declaration/CtSealable.java

@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ *
+ * Copyright (C) 2006-2019 INRIA and contributors
+ *
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) of the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+package spoon.reflect.declaration;
+
+import spoon.reflect.annotations.PropertyGetter;
+import spoon.reflect.annotations.PropertySetter;
+import spoon.reflect.path.CtRole;
+import spoon.reflect.reference.CtTypeReference;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * This interface represents any type that can be sealed.
+ * See JLS 8.1.1.2
+ */
+public interface CtSealable {
+
+	/**
+	 * Returns the permitted types for this type.
+	 *
+	 * @return an unmodifiable view of the permitted types.
+	 */
+	@PropertyGetter(role = CtRole.PERMITTED_TYPE)
+	Set<CtTypeReference<?>> getPermittedTypes();
+
+	/**
+	 * Sets the permitted types for this type.
+	 * Calling this method does not change the state of the {@link ModifierKind#SEALED} for this type.
+	 * The previously permitted types will be removed.
+	 *
+	 * @param permittedTypes the permitted types to set.
+	 * @return this.
+	 */
+	@PropertySetter(role = CtRole.PERMITTED_TYPE)
+	CtSealable setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes);
+
+	/**
+	 * Adds a permitted type to this type.
+	 * Calling this method does not change the state of the {@link ModifierKind#SEALED} for this type.
+	 *
+	 * @param type the type to add as permitted type.
+	 * @return this.
+	 */
+	@PropertySetter(role = CtRole.PERMITTED_TYPE)
+	CtSealable addPermittedType(CtTypeReference<?> type);
+
+	/**
+	 * Adds a permitted type to this type.
+	 * Calling this method does not change the state of the {@link ModifierKind#SEALED} for this type.
+	 *
+	 * @param type the type to remove from this type's permitted types.
+	 * @return this.
+	 */
+	@PropertySetter(role = CtRole.PERMITTED_TYPE)
+	CtSealable removePermittedType(CtTypeReference<?> type);
+}

src/main/java/spoon/reflect/declaration/ModifierKind.java

@@ -20,58 +20,67 @@ public enum ModifierKind {
 	/**
 	 * The modifier <tt>public</tt>
 	 */
-	PUBLIC,
+	PUBLIC("public"),
 	/**
 	 * The modifier <tt>protected</tt>
 	 */
-	PROTECTED,
+	PROTECTED("protected"),
 	/**
 	 * The modifier <tt>private</tt>
 	 */
-	PRIVATE,
+	PRIVATE("private"),
 	/**
 	 * The modifier <tt>abstract</tt>
 	 */
-	ABSTRACT,
+	ABSTRACT("abstract"),
 	/**
 	 * The modifier <tt>static</tt>
 	 */
-	STATIC,
+	STATIC("static"),
 	/**
 	 * The modifier <tt>final</tt>
 	 */
-	FINAL,
+	FINAL("final"),
 	/**
 	 * The modifier <tt>transient</tt>
 	 */
-	TRANSIENT,
+	TRANSIENT("transient"),
 	/**
 	 * The modifier <tt>volatile</tt>
 	 */
-	VOLATILE,
+	VOLATILE("volatile"),
 	/**
 	 * The modifier <tt>synchronized</tt>
 	 */
-	SYNCHRONIZED,
+	SYNCHRONIZED("synchronized"),
 	/**
 	 * The modifier <tt>native</tt>
 	 */
-	NATIVE,
+	NATIVE("native"),
 	/**
 	 * The modifier <tt>strictfp</tt>
 	 */
-	STRICTFP;
+	STRICTFP("strictfp"),
+	/**
+	 * The modifier <tt>non-sealed</tt>
+	 */
+	NON_SEALED("non-sealed"),
+	/**
+	 * The modifier <tt>sealed</tt>
+	 */
+	SEALED("sealed");
+
+	ModifierKind(String lowercase) {
+		this.lowercase = lowercase;
+	}
 
-	private String lowercase = null; // modifier name in lowercase
+	private final String lowercase; // modifier name in lowercase
 
 	/**
 	 * Returns this modifier's name in lowercase.
 	 */
 	@Override
 	public String toString() {
-		if (lowercase == null) {
-			lowercase = name().toLowerCase(java.util.Locale.US);
-		}
 		return lowercase;
 	}