diff options
5 files changed, 295 insertions, 65 deletions
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SealedTypes15Tests.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SealedTypes15Tests.java index 7f54843813..efcc6433fc 100644 --- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SealedTypes15Tests.java +++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/SealedTypes15Tests.java @@ -151,7 +151,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " System.out.println(0);\n" + " }\n"+ "}\n" + - "sealed interface SI permits X, I{}\n" + "sealed interface SI permits X, I{}\n" + + "non-sealed interface I2 extends I{}\n" }, "0"); } @@ -159,10 +160,12 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { runConformTest( new String[] { "X.java", - "sealed class X {\n"+ + "sealed class X permits Y {\n"+ " public static void main(String[] args){\n"+ " System.out.println(100);\n" + " }\n"+ + "}\n" + + "non-sealed class Y extends X {\n"+ "}\n" }, "100"); @@ -176,6 +179,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " int sealed = 100;\n" + " System.out.println(sealed);\n" + " }\n"+ + "}\n" + + "non-sealed class Y extends X {\n"+ "}\n" }, "100"); @@ -188,6 +193,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " public static void main(String[] args){\n"+ " System.out.println(100);\n" + " }\n"+ + "}\n" + + "non-sealed class Y extends X {\n"+ "}\n" }, "100"); @@ -201,6 +208,23 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " public static void main(String[] args){\n"+ " System.out.println(100);\n" + " }\n"+ + "}\n" + + "non-sealed class Y<T> extends X<T> {\n"+ + "}\n" + + "non-sealed interface I2 extends I {}\n" + }, + "100"); + } + public void testBug562715_004a() { + runConformTest( + new String[] { + "X.java", + "sealed public class X<T> {\n"+ + " public static void main(String[] args){\n"+ + " System.out.println(100);\n" + + " }\n"+ + "}\n" + + "non-sealed class Y extends X {\n"+ "}\n" }, "100"); @@ -220,6 +244,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " sealed public sealed class X {\n" + " ^\n" + "Duplicate modifier for the type X\n" + + "----------\n" + + "2. ERROR in X.java (at line 1)\n" + + " sealed public sealed class X {\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares X as its direct superclass\n" + "----------\n"); } public void testBug562715_006() { @@ -233,7 +262,12 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "}", }, "----------\n" + - "1. ERROR in X.java (at line 2)\n" + + "1. ERROR in X.java (at line 1)\n" + + " public sealed class X {\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares X as its direct superclass\n" + + "----------\n" + + "2. ERROR in X.java (at line 2)\n" + " public static sealed void main(String[] args){\n" + " ^^^^^^\n" + "Syntax error on token \"sealed\", static expected\n" + @@ -248,7 +282,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " System.out.println(100);\n" + " }\n"+ "}\n" + - "@interface MyAnnot {}\n" + "@interface MyAnnot {}\n" + + "non-sealed class Y extends X{}" }, "100"); } @@ -261,7 +296,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " System.out.println(100);\n" + " }\n"+ "}\n"+ - "sealed class Y extends X {}\n" + "sealed class Y extends X {}\n" + + "final class Z extends Y {}\n" }, "100"); } @@ -275,7 +311,8 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " }\n"+ "}\n"+ "sealed class Y extends X {}\n" + - "final class Z extends X {}\n" + "final class Z extends X {}\n" + + "final class Y2 extends Y {}\n" }, "100"); } @@ -292,6 +329,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "----------\n" + "1. ERROR in X.java (at line 1)\n" + " public sealed class X permits {\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares X as its direct superclass\n" + + "----------\n" + + "2. ERROR in X.java (at line 1)\n" + + " public sealed class X permits {\n" + " ^^^^^^^\n" + "Syntax error on token \"permits\", ClassType expected after this token\n" + "----------\n"); @@ -386,6 +428,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "----------\n" + "1. ERROR in p1\\A.java (at line 2)\n" + " public sealed class A extends X{}\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares A as its direct superclass\n" + + "----------\n" + + "2. ERROR in p1\\A.java (at line 2)\n" + + " public sealed class A extends X{}\n" + " ^\n" + "The type A extending a sealed class X should be a permitted subtype of X\n" + "----------\n"); @@ -520,19 +567,17 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "----------\n"); } public void testBug563806_009() { - this.runNegativeTest( + this.runConformTest( new String[] { "X.java", "public sealed class X {\n"+ + " public static void main(String[] args){\n"+ + " System.out.println(100);\n" + + " }\n"+ "}\n"+ "final class Y extends X {}", }, - "----------\n" + - "1. ERROR in X.java (at line 3)\n" + - " final class Y extends X {}\n" + - " ^\n" + - "The type Y extending a sealed class X should be a permitted subtype of X\n" + - "----------\n"); + "100"); } public void testBug563806_010() { this.runNegativeTest( @@ -554,19 +599,19 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "----------\n"); } public void testBug563806_011() { - this.runNegativeTest( + this.runConformTest( new String[] { "X.java", - "public sealed interface X {\n"+ + "public class X {\n" + + " public static void main(String[] args) { \n" + + " System.out.println(\"0\");\n" + + " }\n" + + "}\n" + + "sealed interface Y {\n"+ "}\n"+ - "final class Y implements X {}", + "final class Z implements Y {}", }, - "----------\n" + - "1. ERROR in X.java (at line 3)\n" + - " final class Y implements X {}\n" + - " ^\n" + - "The type Y extending a sealed class X should be a permitted subtype of X\n" + - "----------\n"); + "0"); } public void testBug563806_012() { this.runNegativeTest( @@ -600,11 +645,6 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " interface Y extends X {}\n" + " ^\n" + "The interface Y with a sealed direct superinterface X should be declared either sealed or non-sealed\n" + - "----------\n" + - "2. ERROR in X.java (at line 3)\n" + - " interface Y extends X {}\n" + - " ^\n" + - "The type Y extending a sealed interface X should be a permitted subtype of X\n" + "----------\n"); } public void testBug563806_014() { @@ -744,10 +784,10 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "package p1;\n"+ "public sealed interface X permits Y, p2.Y {\n"+ "}\n"+ - "sealed interface Y extends X{}\n", + "non-sealed interface Y extends X{}\n", "p2/Y.java", "package p2;\n"+ - "public sealed interface Y extends p1.X{}", + "public non-sealed interface Y extends p1.X{}", }, "----------\n" + "1. ERROR in p1\\X.java (at line 2)\n" + @@ -845,7 +885,7 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "package p1;\n"+ "public sealed interface X permits Y, p2.Y {\n"+ "}\n"+ - "sealed interface Y extends X{}\n", + "non-sealed interface Y extends X{}\n", "p2/Y.java", "package p2;\n"+ "public interface Y {}", @@ -913,10 +953,10 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "package p1;\n"+ "public sealed interface X permits Y, p2.Y {\n"+ "}\n"+ - "sealed interface Y extends X{}\n", + "non-sealed interface Y extends X{}\n", "p2/Y.java", "package p2;\n"+ - "public sealed interface Y extends p1.X {}", + "public non-sealed interface Y extends p1.X {}", }; runner.runConformTest(); } @@ -994,6 +1034,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "1. ERROR in p1\\X.java (at line 2)\n" + " public sealed non-sealed interface X {\n" + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares X as its direct superclass\n" + + "----------\n" + + "2. ERROR in p1\\X.java (at line 2)\n" + + " public sealed non-sealed interface X {\n" + + " ^\n" + "An interface X is declared both sealed and non-sealed\n" + "----------\n"); } @@ -1058,6 +1103,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " sealed class Y{}\n" + " ^\n" + "Illegal modifier for the local class Y; only abstract or final is permitted\n" + + "----------\n" + + "2. ERROR in p1\\X.java (at line 4)\n" + + " sealed class Y{}\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares Y as its direct superclass\n" + "----------\n"); } public void testBug563806_037() { @@ -1094,6 +1144,11 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { " non-sealed sealed class Y{}\n" + " ^\n" + "Illegal modifier for the local class Y; only abstract or final is permitted\n" + + "----------\n" + + "2. ERROR in p1\\X.java (at line 4)\n" + + " non-sealed sealed class Y{}\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares Y as its direct superclass\n" + "----------\n"); } public void testBug563806_039() { @@ -1109,7 +1164,12 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "}\n", }, "----------\n" + - "1. ERROR in p1\\X.java (at line 5)\n" + + "1. ERROR in p1\\X.java (at line 2)\n" + + " sealed class A{}\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares A as its direct superclass\n" + + "----------\n" + + "2. ERROR in p1\\X.java (at line 5)\n" + " class Y extends A{}\n" + " ^\n" + "A local class Y cannot have a sealed direct superclass or a sealed direct superinterface A\n" + @@ -1136,4 +1196,142 @@ public class SealedTypes15Tests extends AbstractRegressionTest9 { "}"; verifyClassFile(expectedOutput, "p1/X.class", ClassFileBytesDisassembler.SYSTEM); } + // Test that implicit permitted (top-level) types make it to the .class file + public void testBug564190_1() throws IOException, ClassFormatException { + runConformTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " public static void main(String[] args){\n"+ + " System.out.println(0);\n" + + " }\n"+ + "}\n" + + "final class Y extends X{}\n" + + "final class Z extends X{}\n", + }, + "0"); + String expectedOutput = + "PermittedSubclasses:\n" + + " #33 p1/Y,\n" + + " #35 p1/Z\n" + + "}"; + verifyClassFile(expectedOutput, "p1/X.class", ClassFileBytesDisassembler.SYSTEM); + } + // Test that implicit permitted final (member) types make it to the .class file + public void testBug564190_2() throws IOException, ClassFormatException { + runConformTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " public static void main(String[] args){\n"+ + " System.out.println(0);\n" + + " }\n"+ + " final class Y extends X{}\n" + + " final class Z extends X{}\n" + + "}", + }, + "0"); + String expectedOutput = + "PermittedSubclasses:\n" + + " #33 p1/X$Y,\n" + + " #36 p1/X$Z\n" + + "}"; + verifyClassFile(expectedOutput, "p1/X.class", ClassFileBytesDisassembler.SYSTEM); + } + // Test that implicit permitted non-sealed (member) types make it to the .class file + public void testBug564190_3() throws IOException, ClassFormatException { + runConformTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " public static void main(String[] args){\n"+ + " System.out.println(0);\n" + + " }\n"+ + " non-sealed class Y extends X{}\n" + + " non-sealed class Z extends X{}\n" + + "}", + }, + "0"); + String expectedOutput = + "PermittedSubclasses:\n" + + " #33 p1/X$Y,\n" + + " #36 p1/X$Z\n" + + "}"; + verifyClassFile(expectedOutput, "p1/X.class", ClassFileBytesDisassembler.SYSTEM); + } + // Test that implicit permitted member type is reported without final, sealed or non-sealed + public void testBug564190_4() throws IOException, ClassFormatException { + runNegativeTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " class Y extends X {}\n" + + " final class Z extends Y {}\n" + + "}", + }, + "----------\n" + + "1. ERROR in p1\\X.java (at line 3)\n" + + " class Y extends X {}\n" + + " ^\n" + + "The class Y with a sealed direct superclass or a sealed direct superinterface X should be declared either final, sealed, or non-sealed\n" + + "----------\n"); + } + // Test that implicit permitted member type with implicit permitted types + // is reported when its permitted type doesn't extend the member type + public void testBug564190_5() throws IOException, ClassFormatException { + runNegativeTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " sealed class Y extends X {}\n" + + " final class Z {}\n" + + "}", + }, + "----------\n" + + "1. ERROR in p1\\X.java (at line 3)\n" + + " sealed class Y extends X {}\n" + + " ^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares Y as its direct superclass\n" + + "----------\n"); + } + // Test that implicit permitted member type with explicit permits clause + // is reported when its permitted type doesn't extend the member type + public void testBug564190_6() throws IOException, ClassFormatException { + runNegativeTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed class X {\n" + + " sealed class Y extends X permits Z {}\n" + + " final class Z {}\n" + + "}", + }, + "----------\n" + + "1. ERROR in p1\\X.java (at line 3)\n" + + " sealed class Y extends X permits Z {}\n" + + " ^\n" + + "Permitted class Z does not declare p1.X.Y as direct super class\n" + + "----------\n"); + } + // Test that implicit permitted member type with explicit permits clause + // is reported when its permitted type doesn't extend the member type + public void testBug564190_7() throws IOException, ClassFormatException { + runNegativeTest( + new String[] { + "p1/X.java", + "package p1;\n"+ + "sealed interface SI {}", + }, + "----------\n" + + "1. ERROR in p1\\X.java (at line 2)\n" + + " sealed interface SI {}\n" + + " ^^\n" + + "Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares SI as its direct superclass\n" + + "----------\n"); + } } diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java index 50ce1e7bc6..eec680fda3 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java @@ -39,6 +39,7 @@ package org.eclipse.jdt.internal.compiler.lookup; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; +import java.util.List; import java.util.Map; import org.eclipse.jdt.core.compiler.CharOperation; import org.eclipse.jdt.internal.compiler.ast.ASTNode; @@ -327,6 +328,7 @@ public class ClassScope extends Scope { LocalTypeBinding localType = buildLocalType(enclosingType, enclosingType.fPackage); connectTypeHierarchy(); + connectPermittedTypes(); if (compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) { checkParameterizedTypeBounds(); checkParameterizedSuperTypeCollisions(); @@ -1049,6 +1051,8 @@ public class ClassScope extends Scope { if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES) { for (int i = 0, size = memberTypes.length; i < size; i++) ((SourceTypeBinding) memberTypes[i]).scope.connectTypeHierarchy(); + for (int i = 0, size = memberTypes.length; i < size; i++) + ((SourceTypeBinding) memberTypes[i]).scope.connectPermittedTypes(); } } /* @@ -1156,16 +1160,53 @@ public class ClassScope extends Scope { return !foundCycle; } - private boolean connectPermittedTypes() { + void connectPermittedTypes() { SourceTypeBinding sourceType = this.referenceContext.binding; sourceType.setPermittedTypes(Binding.NO_PERMITTEDTYPES); + if (sourceType.id == TypeIds.T_JavaLangObject || sourceType.isEnum()) // already handled + return; + if (this.referenceContext.permittedTypes == null) { - return true; + // When both sealed and non-sealed are used, an error is reported further + // down the line. Let's ignore it here and move on. + if (sourceType.isSealed()) { + // First top level types + SourceTypeBinding[] topLevelTypes = compilationUnitScope().topLevelTypes; + List<ReferenceBinding> permitted = null; + if (topLevelTypes != null) { + for (SourceTypeBinding subtype : topLevelTypes) { + if (!TypeBinding.equalsEquals(subtype, sourceType)) { + if (subtype.findSuperTypeOriginatingFrom(sourceType) != null) { + if (permitted == null) + permitted = new ArrayList<>(); + permitted.add(subtype); + } + } + } + } + // And nested types + if (sourceType.memberTypes != null) { + for (ReferenceBinding subtype : sourceType.memberTypes) { + if (!TypeBinding.equalsEquals(subtype, sourceType)) + if (subtype.findSuperTypeOriginatingFrom(sourceType) != null) { + if (permitted == null) + permitted = new ArrayList<>(); + permitted.add(subtype); + } + } + } + if (permitted == null || permitted.size() == 0) { + problemReporter().sealedSealedTypeMissingPermits(sourceType, this.referenceContext); + } else { + ReferenceBinding[] permittedTypeBindings = new ReferenceBinding[permitted.size()]; + permitted.toArray(permittedTypeBindings); + sourceType.setPermittedTypes(permittedTypeBindings); + return; + } + } + sourceType.setPermittedTypes(Binding.NO_PERMITTEDTYPES); + return; } - if (sourceType.id == TypeIds.T_JavaLangObject) // already handled the case of redefining java.lang.Object - return true; - - boolean noProblems = true; int length = this.referenceContext.permittedTypes.length; ReferenceBinding[] permittedTypeBindings = new ReferenceBinding[length]; int count = 0; @@ -1173,8 +1214,6 @@ public class ClassScope extends Scope { TypeReference permittedTypeRef = this.referenceContext.permittedTypes[i]; ReferenceBinding permittedType = findPermittedtype(permittedTypeRef); if (permittedType == null) { // detected cycle - sourceType.tagBits |= TagBits.HierarchyHasProblems; - noProblems = false; continue nextPermittedType; } // check for simple interface collisions @@ -1182,16 +1221,9 @@ public class ClassScope extends Scope { for (int j = 0; j < i; j++) { if (TypeBinding.equalsEquals(permittedTypeBindings[j], permittedType)) { problemReporter().sealedDuplicateTypeInPermits(sourceType, permittedTypeRef, permittedType); - sourceType.tagBits |= TagBits.HierarchyHasProblems; - noProblems = false; continue nextPermittedType; } } - if ((permittedType.tagBits & TagBits.HierarchyHasProblems) != 0 - || !permittedTypeRef.resolvedType.isValidBinding()) { - sourceType.tagBits |= TagBits.HierarchyHasProblems; // propagate if missing supertype - noProblems &= permittedTypeRef.resolvedType.isValidBinding(); - } // only want to reach here when no errors are reported permittedTypeBindings[count++] = permittedType; } @@ -1200,8 +1232,9 @@ public class ClassScope extends Scope { if (count != length) System.arraycopy(permittedTypeBindings, 0, permittedTypeBindings = new ReferenceBinding[count], 0, count); sourceType.setPermittedTypes(permittedTypeBindings); + } else { + sourceType.setPermittedTypes(Binding.NO_PERMITTEDTYPES); } - return noProblems; } private boolean connectRecordSuperclass() { @@ -1308,7 +1341,6 @@ public class ClassScope extends Scope { environment().typesBeingConnected.add(sourceType); boolean noProblems = connectSuperclass(); noProblems &= connectSuperInterfaces(); - noProblems &= connectPermittedTypes(); environment().typesBeingConnected.remove(sourceType); sourceType.tagBits |= TagBits.EndHierarchyCheck; noProblems &= connectTypeVariables(this.referenceContext.typeParameters, false); @@ -1367,7 +1399,7 @@ public class ClassScope extends Scope { environment().typesBeingConnected.add(sourceType); boolean noProblems = connectSuperclass(); noProblems &= connectSuperInterfaces(); - noProblems &= connectPermittedTypes(); + connectPermittedTypes(); environment().typesBeingConnected.remove(sourceType); sourceType.tagBits |= TagBits.EndHierarchyCheck; noProblems &= connectTypeVariables(this.referenceContext.typeParameters, false); diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java index 2d3d952226..bce612e08c 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java @@ -365,6 +365,10 @@ public char[] computeConstantPoolName(LocalTypeBinding localType) { void connectTypeHierarchy() { for (int i = 0, length = this.topLevelTypes.length; i < length; i++) this.topLevelTypes[i].scope.connectTypeHierarchy(); + // Wait for all hierarchy information to be built before + // checking on permitted types + for (int i = 0, length = this.topLevelTypes.length; i < length; i++) + this.topLevelTypes[i].scope.connectPermittedTypes(); } void faultInImports() { if (this.tempImports != null) diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java index a029a0b8ea..8a4ccc50bb 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java @@ -1169,6 +1169,13 @@ private void checkPermitsInType() { } } } + for (int i = 0, length = this.memberTypes.length; i < length; i++) + ((SourceTypeBinding) this.memberTypes[i]).checkPermitsInType(); + + if (this.scope.referenceContext.permittedTypes == null) { + // Ignore implicitly permitted case + return; + } for (int i = 0, l = this.permittedTypes.length; i < l; i++) { TypeReference permittedTypeRef = this.scope.referenceContext.permittedTypes[i]; ReferenceBinding permittedType = this.permittedTypes[i]; @@ -1234,20 +1241,13 @@ private boolean checkPermitsAndAdd(ReferenceBinding superType, List<SourceTypeBi || superType.equals(this.scope.getJavaLangObject())) return true; if (superType.isSealed()) { + if (superType.isParameterizedType() || superType.isRawType()) + superType = superType.actualType(); ReferenceBinding[] superPermittedTypes = superType.permittedTypes(); for (ReferenceBinding permittedType : superPermittedTypes) { if (permittedType.isValidBinding() && TypeBinding.equalsEquals(this, permittedType)) return true; } - // add this if the super type also in the same compilation unit - implicitly permits -// if (types.contains(this)) { -// int len = superPermittedTypes.length; -// ReferenceBinding[] newPermTypes = new ReferenceBinding [len + 1]; -// System.arraycopy(superPermittedTypes, 0, newPermTypes, 0, len); -// newPermTypes[len] = this; -// ((SourceTypeBinding) superType).setPermittedTypes(newPermTypes); -// return true; -// } } return false; } diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties index c2591bc9c8..3ad334d68e 100644 --- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties +++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties @@ -1088,7 +1088,7 @@ 1857 = Permitted class {0} does not declare {1} as direct super class 1858 = Permitted type {0} in a named module {1} should be declared in the same module {1} of declaring type {2} 1859 = Permitted type {0} in an unnamed module should be declared in the same package {1} of declaring type {2} -1860 = TODO the declaration of a sealed class C lacks a permits clause and no top level or nested class declared in the same compilation unit as C names C as its direct superclass. - 8.1.6 #SealedSealedTypeMissingPermits +1860 = Sealed class lacks the permits clause and no top level or nested class from the same compilation unit declares {0} as its direct superclass #1861 = done via 750 751, 753 an enum declaration has the modifier abstract, or final, sealed or non-sealed. - 8.1.9 #SealedEnumHasDisallowedModifiers 1862 = An interface {0} is declared both sealed and non-sealed 1863 = An interface {0} declared as non-sealed should have a sealed direct superinterface @@ -1096,11 +1096,7 @@ #1853 = an InterfaceType names an interface that is sealed (9.1.1.3) and the interface being declared is not a permitted subinterface of the named interface (9.1.4).- 9.1.3 #SealedSuperInterfaceDoesNotPermit #1854 = an interface declaration has a permits clause but the declared interface is not sealed. - 9.1.4 #SealedMissingSealedModifier #1450 = Every TypeName in the permits clause of an interface declaration must denote an accessible class or interface (6.6); otherwise a compile-time error occurs. - 9.1.4 #SealedPermittedTypeNotAccessible -#1856 = a class or interface is named more than once in a single permits clause. This is true even if the class or interface is named in different ways. - 9.1.4 #SealedDuplicateTypeInPermits 1864 = Permitted type {0} does not declare {1} as direct super interface -#1858 = If a sealed interface I belongs to a named module, then every class or interface named in the permits clause of the declaration of I must belong to the same module as I; otherwise a compile-time error occurs. - 9.1.4 #SealedPermittedTypeOutsideOfModule -#1859 = If a sealed interface I belongs to an unnamed module, then every class or interface named in the permits clause of the declaration of I must belong to the same package as I; otherwise a compile-time error occurs. - 9.1.4 #SealedPermittedTypeOutsideOfPackage -#1860 = the declaration of a sealed interface I lacks a permits clause and no top level or nested class or interface declared in the same compilation unit as I names I as a direct superinterface. - 9.1.4 #SealedSealedTypeMissingPermits #1865 = covered by syntax error an annotation type declaration has the modifier sealed (9.1.1.3). - 9.6 #SealedDisAllowedSealedModifier #1866 = Covered by 302 a local class declaration contains any of the access modifiers public, protected, or private (6.6), or the modifier any of the modifiers static (8.1.1), sealed or non-sealed (8.1.1.2). - 14.3 #SealedDisAllowedModifierInLocalClass 1867 = A local class {1} cannot have a sealed direct superclass or a sealed direct superinterface {0} |