jdk-24/test/langtools/tools/javac/patterns/DeconstructionDesugaring.java

/*
 * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/**
 * @test
 * @bug 8291769 8301858 8304694 8304883
 * @summary Verify more complex switches work properly
 * @compile DeconstructionDesugaring.java
 * @run main DeconstructionDesugaring
 */

import java.util.Objects;
import java.util.function.ToIntFunction;
public class DeconstructionDesugaring {

    public static void main(String... args) throws Throwable {
        new DeconstructionDesugaring().test();
    }

    private void test() {
        test(this::runCheckStatement);
        test(this::runCheckExpression);
        assertEquals(runCheckExpressionWithUnconditional(new R5(new R4(new Sub3()))), 3);
        assertEquals(runCheckExpressionWithUnconditional(new R5(new R4(null))), 3);
        assertEquals(runCheckExpressionWithUnconditional1(new R5(new R4(null))), 2);
        assertEquals(runCheckExpressionWithUnconditional1(new R5(null)), 3);
        assertEquals(runCheckExpressionWithUnconditionalAndParams(new R1(42)), 1);
        assertEquals(runCheckExpressionWithUnconditionalAndParams(new R1(new Object())), 2);
        assertEquals(switchNullable1(new R6(0, 0)), "int: 0, int: 0");
        assertEquals(switchNullable1(new R6(0L, 0)), "obj: 0, obj: 0");
        assertEquals(switchNullable2(new R6(0, 0)), "int: 0, int: 0");
        assertEquals(switchNullable2(new R6(0L, 0)), "obj: 0, int: 0");
        assertEquals(switchNullable2(new R6(0, 0L)), "int: 0, obj: 0");
        assertEquals(switchNullable2(new R6(0L, 0L)), "obj: 0, obj: 0");
        assertEquals(switchNullableNPE(new R6(1, 1)), "obj: 1, obj: 1");
        try {
            switchNullableNPE(new R6(null, 1));
            throw new AssertionError("Expected NPE, but got none.");
        } catch (NullPointerException ex) {
            //expected.
        }
        assertEquals(runFallThrough(new R7(1, 1)), 0);
        assertEquals(runFallThrough(new R7(0, 0)), 1);
    }

    private void test(ToIntFunction<Object> task) {
        assertEquals(1, task.applyAsInt(new R1(new R2(""))));
        assertEquals(2, task.applyAsInt(new R1(new R2(1))));
        assertEquals(3, task.applyAsInt(new R1(new R2(1.0))));
        assertEquals(-1, task.applyAsInt(new R1(new R2(null))));
        assertEquals(4, task.applyAsInt(new R1(new R2(new StringBuilder()))));
        assertEquals(5, task.applyAsInt(new R1(new R3(""))));
        assertEquals(6, task.applyAsInt(new R1(new R3(1))));
        assertEquals(7, task.applyAsInt(new R1(new R3(1.0))));
        assertEquals(8, task.applyAsInt(new R1(new R3(new StringBuilder()))));
        assertEquals(-1, task.applyAsInt(new R1(1.0f)));
        assertEquals(-1, task.applyAsInt("foo"));
    }

    private int runCheckStatement(Object o) {
        switch (o) {
            case R1(R2(String s)) -> { return 1; }
            case R1(R2(Integer i)) -> { return 2; }
            case R1(R2(Double d)) -> { return 3; }
            case R1(R2(CharSequence cs)) -> { return 4; }
            case R1(R3(String s)) -> { return 5; }
            case R1(R3(Integer i)) -> { return 6; }
            case R1(R3(Double f)) -> { return 7; }
            case R1(R3(CharSequence cs)) -> { return 8; }
            default -> { return -1; }
        }
    }

    private int runCheckExpression(Object o) {
        return switch (o) {
            case R1(R2(String s)) -> 1;
            case R1(R2(Integer i)) -> 2;
            case R1(R2(Double d)) -> 3;
            case R1(R2(CharSequence cs)) -> 4;
            case R1(R3(String s)) -> 5;
            case R1(R3(Integer i)) -> 6;
            case R1(R3(Double f)) -> 7;
            case R1(R3(CharSequence cs)) -> 8;
            default -> -1;
        };
    }

    private int runCheckExpressionWithUnconditional(R5 o) {
        return switch (o) {
            case R5(R4(Sub1 s)) -> 1;
            case R5(R4(Sub2 s)) -> 2;
            case R5(R4(Super s)) -> 3;
        };
    }

    private int runCheckExpressionWithUnconditional1(R5 o) {
        return switch (o) {
            case R5(R4(Sub1 s)) -> 1;
            case R5(R4(Super s)) -> 2;
            case R5(Object obj) -> 3;
        };
    }

    public static int runCheckExpressionWithUnconditionalAndParams(R1 r) {
        switch (r) {
            case R1(Integer i):
                return meth_I(i);
            case R1(Object o):
                return meth_O(o);
        }
    }

    private String switchNullable1(R6 r) {
        return switch (r) {
            case R6(Integer i1, Integer i2) -> "int: " + i1 + ", int: " + i2;
            case R6(Object o1, Object o2) -> "obj: " + o1 + ", obj: " + o2;
        };
    }

    private String switchNullable2(R6 r) {
        return switch (r) {
            case R6(Integer i1, Integer i2) -> "int: " + i1 + ", int: " + i2;
            case R6(Integer i1, Object o2) -> "int: " + i1 + ", obj: " + o2;
            case R6(Object o1, Integer i2) -> "obj: " + o1 + ", int: " + i2;
            case R6(Object o1, Object o2) -> "obj: " + o1 + ", obj: " + o2;
        };
    }

    private String switchNullableNPE(R6 r) {
        return switch (r) {
            case R6(Object o1, Object o2) when ((int) o1) == 0 && ((int) o2) == 0 -> "int: " + o1 + ", int: " + o2;
            case R6(Object o1, Object o2) -> "obj: " + o1 + ", obj: " + o2;
        };
    }

    public static int runFallThrough(R7 r) {
        switch (r) {
            case R7(var v1, var v2) when v1 != 0: return 0;
            case R7(var v1, var v2):
        }
        return 1;
    }

    public static int meth_I(Integer i) { return 1; }
    public static int meth_O(Object o) { return 2;}

    private void assertEquals(int expected, int actual) {
        if (expected != actual) {
            throw new AssertionError("expected: " + expected + ", " +
                                     "actual: " + actual);
        }
    }

    private void assertEquals(String expected, String actual) {
        if (!Objects.equals(expected, actual)) {
            throw new AssertionError("expected: " + expected + ", " +
                                     "actual: " + actual);
        }
    }

    record R1(Object o) {}
    record R2(Object o) {}
    record R3(Object o) {}

    sealed class Super permits Sub1, Sub2, Sub3 {}
    final class Sub1 extends Super {}
    final class Sub2 extends Super {}
    final class Sub3 extends Super {}

    record R4(Super o) {}
    record R5(R4 o) {}
    record R6(Object o1, Object o2) {}
    record R7(int i1, int i2) {}
}