8303374: Implement JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview)

src/java.base/share/classes/java/lang/runtime/SwitchBootstraps.java

@@ -225,7 +225,7 @@ private static MethodHandle createRepeatIndexSwitch(MethodHandles.Lookup lookup,
                     if (unconditionalExactnessCheck(selectorType, currentLabelClass)) {
                         currentTest = trueDef;
                     } else if (currentLabelClass.isPrimitive()) {
-                         if (selectorType.isInstance(Object.class)) {
+                         if (selectorType.equals(Object.class)) {
                             currentTest = INSTANCEOF_CHECK;
                             if (currentLabelClass.isAssignableFrom(byte.class)) { testLabel = Byte.class; }
                             else if (currentLabelClass.isAssignableFrom(short.class)) { testLabel = Short.class; }
@@ -234,15 +234,6 @@ private static MethodHandle createRepeatIndexSwitch(MethodHandles.Lookup lookup,
                             else if (currentLabelClass.isAssignableFrom(double.class)) { testLabel = Double.class; }
                             else if (currentLabelClass.isAssignableFrom(float.class)) { testLabel = Float.class; }
                             else { testLabel = Long.class; }
-                        } else if (!selectorType.isPrimitive()) {
-                            currentTest = INSTANCEOF_CHECK;
-                            if (currentLabelClass.equals(byte.class)) { testLabel = Byte.class; }
-                            else if (currentLabelClass.equals(short.class)) { testLabel = Short.class; }
-                            else if (currentLabelClass.equals(char.class)) { testLabel = Character.class; }
-                            else if (currentLabelClass.equals(int.class)) { testLabel = Integer.class; }
-                            else if (currentLabelClass.equals(double.class)) { testLabel = Double.class; }
-                            else if (currentLabelClass.equals(float.class)) { testLabel = Float.class; }
-                            else { testLabel = Long.class; }
                         } else {
                             MethodHandle exactnessCheck;
                             try {

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java

@@ -4151,7 +4151,7 @@ public boolean compatible(Type found, Type req, Warner warn) {
 
     public void visitTypeTest(JCInstanceOf tree) {
         Type exprtype = attribExpr(tree.expr, env);
-        if(!allowPrimitivePatterns) {
+        if (!allowPrimitivePatterns) {
             exprtype = chk.checkNullOrRefType(
                     tree.expr.pos(), exprtype);
         } else if (tree.pattern.type != null && exprtype.isPrimitive() && preview.isPreview(Feature.PRIMITIVE_PATTERNS)) {

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java

@@ -732,27 +732,17 @@ public void visitSwitchExpression(JCSwitchExpression tree) {
                     }
                 }
             }
-            if (tree.selector.type.hasTag(TypeTag.BOOLEAN)) {
-                HashSet<JCTree> labelValues = tree.cases.stream()
-                        .filter(TreeInfo::unguardedCase)
-                        .flatMap(c -> c.labels.stream())
-                        .filter(l -> !l.hasTag(DEFAULTCASELABEL))
-                        .map(l -> l.hasTag(CONSTANTCASELABEL) ? ((JCConstantCaseLabel) l).expr
-                                : ((JCPatternCaseLabel) l).pat)
-                        .collect(Collectors.toCollection(HashSet::new));
 
-                boolean hasBothTrueAndFalse = labelValues.stream().filter(l -> l.hasTag(Tag.LITERAL)).map(l -> ((JCLiteral)l).value).distinct().count() == 2;
+            boolean exhaustive = exhausts(tree.selector, tree.cases);
 
-                tree.isExhaustive = hasBothTrueAndFalse || tree.hasUnconditionalPattern;
-
-                if (hasBothTrueAndFalse && tree.hasUnconditionalPattern) {
-                    log.error(tree, Errors.DefaultLabelNotAllowed);
-                }
-            } else {
-                tree.isExhaustive = tree.hasUnconditionalPattern ||
-                        TreeInfo.isErrorEnumSwitch(tree.selector, tree.cases) ||
-                        exhausts(tree.selector, tree.cases);
+            if (tree.selector.type.hasTag(TypeTag.BOOLEAN) && exhaustive && tree.hasUnconditionalPattern) {
+                log.error(tree, Errors.DefaultLabelNotAllowed);
             }
+
+            tree.isExhaustive = tree.hasUnconditionalPattern ||
+                    TreeInfo.isErrorEnumSwitch(tree.selector, tree.cases) ||
+                    exhaustive;
+
             if (!tree.isExhaustive) {
                 log.error(tree, Errors.NotExhaustive);
             }
@@ -763,6 +753,7 @@ public void visitSwitchExpression(JCSwitchExpression tree) {
         private boolean exhausts(JCExpression selector, List<JCCase> cases) {
             Set<PatternDescription> patternSet = new HashSet<>();
             Map<Symbol, Set<Symbol>> enum2Constants = new HashMap<>();
+            Set<Object> booleanLiterals = new HashSet<>();
             for (JCCase c : cases) {
                 if (!TreeInfo.unguardedCase(c))
                     continue;
@@ -773,19 +764,29 @@ private boolean exhausts(JCExpression selector, List<JCCase> cases) {
                             patternSet.add(makePatternDescription(component, patternLabel.pat));
                         }
                     } else if (l instanceof JCConstantCaseLabel constantLabel) {
-                        Symbol s = TreeInfo.symbol(constantLabel.expr);
-                        if (s != null && s.isEnum()) {
-                            enum2Constants.computeIfAbsent(s.owner, x -> {
-                                Set<Symbol> result = new HashSet<>();
-                                s.owner.members()
-                                       .getSymbols(sym -> sym.kind == Kind.VAR && sym.isEnum())
-                                       .forEach(result::add);
-                                return result;
-                            }).remove(s);
+                        if (selector.type.hasTag(TypeTag.BOOLEAN)) {
+                            Object value = ((JCLiteral) constantLabel.expr).value;
+                            booleanLiterals.add(value);
+                        } else {
+                            Symbol s = TreeInfo.symbol(constantLabel.expr);
+                            if (s != null && s.isEnum()) {
+                                enum2Constants.computeIfAbsent(s.owner, x -> {
+                                    Set<Symbol> result = new HashSet<>();
+                                    s.owner.members()
+                                            .getSymbols(sym -> sym.kind == Kind.VAR && sym.isEnum())
+                                            .forEach(result::add);
+                                    return result;
+                                }).remove(s);
+                            }
                         }
                     }
                 }
             }
+
+            if (selector.type.hasTag(TypeTag.BOOLEAN) && booleanLiterals.size() == 2) {
+                return true;
+            }
+
             for (Entry<Symbol, Set<Symbol>> e : enum2Constants.entrySet()) {
                 if (e.getValue().isEmpty()) {
                     patternSet.add(new BindingPattern(e.getKey().type));