undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/langtools/tools/javac/patterns/GenericRecordDeconstructionPattern.java

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2022, 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 8298184
+ * @compile GenericRecordDeconstructionPattern.java
+ * @run main GenericRecordDeconstructionPattern
+ */
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+
+public class GenericRecordDeconstructionPattern {
+
+    public static void main(String... args) throws Throwable {
+        new GenericRecordDeconstructionPattern().run();
+    }
+
+    void run() {
+        runTest(this::runIf);
+        runTest(this::runSwitch);
+        runTest(this::runSwitchExpression);
+        runTest(this::runSwitchInference1);
+        runTest(this::runSwitchInference2);
+        runTest(this::runSwitchInference3);
+        runTest(this::runSwitchInference4);
+        testInference3();
+        assertEquals(1, runIfSuperBound(new Box<>(new StringBuilder())));
+        assertEquals(1, runIfSuperBound(new Box<>(0)));
+    }
+
+    void runTest(Function<Box<String>, Integer> test) {
+        Box<String> b = new Box<>(null);
+        assertEquals(1, test.apply(b));
+    }
+
+    int runIf(Box<String> b) {
+        if (b instanceof Box<String>(String s)) return 1;
+        return -1;
+    }
+
+    int runSwitch(Box<String> b) {
+        switch (b) {
+            case Box<String>(String s): return 1;
+            default: return -1;
+        }
+    }
+
+    int runSwitchExpression(Box<String> b) {
+        return switch (b) {
+            case Box<String>(String s) -> 1;
+            default -> -1;
+        };
+    }
+
+    int runSwitchInference1(I<String> b) {
+        switch (b) {
+            case Box(String s): return s == null ? 1 : s.length();
+            default: return -1;
+        }
+    }
+
+    int runSwitchInference2(I<String> b) {
+        switch (b) {
+            case Box(var s): return s == null ? 1 : s.length();
+            default: return -1;
+        }
+    }
+
+    int runSwitchInference3(I<String> b) {
+        return b instanceof Box(var s) ? s == null ? 1 : s.length()
+                                       : -1;
+    }
+
+    <Z extends I<String>> int runSwitchInference4(Z b) {
+        return b instanceof Box(var s) ? s == null ? 1 : s.length()
+                                       : -1;
+    }
+
+    <B extends CharSequence & Runnable, Z extends I<B>> int runSwitchInference5(Z b) {
+        return b instanceof Box(var s) ? s == null ? 1 : s.length()
+                                       : -1;
+    }
+
+    void testInference3() {
+        I<I<String>> b = new Box<>(new Box<>(null));
+        assertEquals(1, runSwitchInferenceNested(b));
+    }
+
+    int runSwitchInferenceNested(I<I<String>> b) {
+        switch (b) {
+            case Box(Box(var s)): return s == null ? 1 : s.length();
+            default: return -1;
+        }
+    }
+
+    int runIfSuperBound(I<? super String> b) {
+        if (b instanceof Box(var v)) return 1;
+        return -1;
+    }
+
+    sealed interface I<T> {}
+    record Box<V>(V v) implements I<V> {
+    }
+
+    void assertEquals(Object expected, Object actual) {
+        if (!Objects.equals(expected, actual)) {
+            throw new AssertionError("Expected: " + expected + "," +
+                                     "got: " + actual);
+        }
+    }
+
+    void fail(String message) {
+        throw new AssertionError(message);
+    }
+
+    public static class TestPatternFailed extends AssertionError {
+
+        public TestPatternFailed(String message) {
+            super(message);
+        }
+
+    }
+
+}