jdk-24/langtools/test/tools/javac/varargs/warning/Warn5.java

/*
 * Copyright (c) 2010, 2011, 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     6993978 7097436
 * @summary Project Coin: Annotation to reduce varargs warnings
 * @author  mcimadamore
 * @run main Warn5
 */
import com.sun.source.util.JavacTask;
import com.sun.tools.javac.api.JavacTool;
import java.net.URI;
import java.util.Arrays;
import java.util.EnumSet;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class Warn5 {

    enum XlintOption {
        NONE("none"),
        ALL("all");

        String opt;

        XlintOption(String opt) {
            this.opt = opt;
        }

        String getXlintOption() {
            return "-Xlint:" + opt;
        }
    }

    enum TrustMe {
        DONT_TRUST(""),
        TRUST("@java.lang.SafeVarargs");

        String anno;

        TrustMe(String anno) {
            this.anno = anno;
        }
    }

    enum SuppressLevel {
        NONE,
        VARARGS;

        String getSuppressAnno() {
            return this == VARARGS ?
                "@SuppressWarnings(\"varargs\")" :
                "";
        }
    }

    enum ModifierKind {
        NONE(""),
        FINAL("final"),
        STATIC("static");

        String mod;

        ModifierKind(String mod) {
            this.mod = mod;
        }
    }

    enum MethodKind {
        METHOD("void m"),
        CONSTRUCTOR("Test");

        String name;

        MethodKind(String name) {
            this.name = name;
        }
    }

    enum SourceLevel {
        JDK_6("6"),
        JDK_7("7");

        String sourceKey;

        SourceLevel(String sourceKey) {
            this.sourceKey = sourceKey;
        }
    }

    enum SignatureKind {
        VARARGS_X("#K <X>#N(X... x)", false, true),
        VARARGS_STRING("#K #N(String... x)", true, true),
        ARRAY_X("#K <X>#N(X[] x)", false, false),
        ARRAY_STRING("#K #N(String[] x)", true, false);

        String stub;
        boolean isReifiableArg;
        boolean isVarargs;

        SignatureKind(String stub, boolean isReifiableArg, boolean isVarargs) {
            this.stub = stub;
            this.isReifiableArg = isReifiableArg;
            this.isVarargs = isVarargs;
        }

        String getSignature(ModifierKind modKind, MethodKind methKind) {
            return methKind != MethodKind.CONSTRUCTOR ?
                stub.replace("#K", modKind.mod).replace("#N", methKind.name) :
                stub.replace("#K", "").replace("#N", methKind.name);
        }
    }

    enum BodyKind {
        ASSIGN("Object o = x;", true),
        CAST("Object o = (Object)x;", true),
        METH("test(x);", true),
        PRINT("System.out.println(x.toString());", false),
        ARRAY_ASSIGN("Object[] o = x;", true),
        ARRAY_CAST("Object[] o = (Object[])x;", true),
        ARRAY_METH("testArr(x);", true);

        String body;
        boolean hasAliasing;

        BodyKind(String body, boolean hasAliasing) {
            this.body = body;
            this.hasAliasing = hasAliasing;
        }
    }

    enum WarningKind {
        UNSAFE_BODY,
        UNSAFE_DECL,
        MALFORMED_SAFEVARARGS,
        REDUNDANT_SAFEVARARGS;
    }

    // Create a single file manager and reuse it for each compile to save time.
    static StandardJavaFileManager fm = JavacTool.create().getStandardFileManager(null, null, null);

    public static void main(String... args) throws Exception {
        for (SourceLevel sourceLevel : SourceLevel.values()) {
            for (XlintOption xlint : XlintOption.values()) {
                for (TrustMe trustMe : TrustMe.values()) {
                    for (SuppressLevel suppressLevel : SuppressLevel.values()) {
                        for (ModifierKind modKind : ModifierKind.values()) {
                            for (MethodKind methKind : MethodKind.values()) {
                                for (SignatureKind sig : SignatureKind.values()) {
                                    for (BodyKind body : BodyKind.values()) {
                                        new Warn5(sourceLevel,
                                                xlint,
                                                trustMe,
                                                suppressLevel,
                                                modKind,
                                                methKind,
                                                sig,
                                                body).test();
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    final SourceLevel sourceLevel;
    final XlintOption xlint;
    final TrustMe trustMe;
    final SuppressLevel suppressLevel;
    final ModifierKind modKind;
    final MethodKind methKind;
    final SignatureKind sig;
    final BodyKind body;
    final JavaSource source;
    final DiagnosticChecker dc;

    public Warn5(SourceLevel sourceLevel, XlintOption xlint, TrustMe trustMe, SuppressLevel suppressLevel, ModifierKind modKind, MethodKind methKind, SignatureKind sig, BodyKind body) {
        this.sourceLevel = sourceLevel;
        this.xlint = xlint;
        this.trustMe = trustMe;
        this.suppressLevel = suppressLevel;
        this.modKind = modKind;
        this.methKind = methKind;
        this.sig = sig;
        this.body = body;
        this.source = new JavaSource();
        this.dc = new DiagnosticChecker();
    }

    void test() throws Exception {
        final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
        JavacTask ct = (JavacTask)tool.getTask(null, fm, dc,
                Arrays.asList(xlint.getXlintOption(), "-source", sourceLevel.sourceKey), null, Arrays.asList(source));
        ct.analyze();
        check();
    }

    void check() {

        EnumSet<WarningKind> expectedWarnings = EnumSet.noneOf(WarningKind.class);

        if (sourceLevel == SourceLevel.JDK_7 &&
                trustMe == TrustMe.TRUST &&
                suppressLevel != SuppressLevel.VARARGS &&
                xlint != XlintOption.NONE &&
                sig.isVarargs && !sig.isReifiableArg && body.hasAliasing &&
                (methKind == MethodKind.CONSTRUCTOR || (methKind == MethodKind.METHOD && modKind != ModifierKind.NONE))) {
            expectedWarnings.add(WarningKind.UNSAFE_BODY);
        }

        if (sourceLevel == SourceLevel.JDK_7 &&
                trustMe == TrustMe.DONT_TRUST &&
                sig.isVarargs &&
                !sig.isReifiableArg &&
                xlint == XlintOption.ALL) {
            expectedWarnings.add(WarningKind.UNSAFE_DECL);
        }

        if (sourceLevel == SourceLevel.JDK_7 &&
                trustMe == TrustMe.TRUST &&
                (!sig.isVarargs ||
                (modKind == ModifierKind.NONE && methKind == MethodKind.METHOD))) {
            expectedWarnings.add(WarningKind.MALFORMED_SAFEVARARGS);
        }

        if (sourceLevel == SourceLevel.JDK_7 &&
                trustMe == TrustMe.TRUST &&
                xlint != XlintOption.NONE &&
                suppressLevel != SuppressLevel.VARARGS &&
                (modKind != ModifierKind.NONE || methKind == MethodKind.CONSTRUCTOR) &&
                sig.isVarargs &&
                sig.isReifiableArg) {
            expectedWarnings.add(WarningKind.REDUNDANT_SAFEVARARGS);
        }

        if (!expectedWarnings.containsAll(dc.warnings) ||
                !dc.warnings.containsAll(expectedWarnings)) {
            throw new Error("invalid diagnostics for source:\n" +
                    source.getCharContent(true) +
                    "\nOptions: " + xlint.getXlintOption() +
                    "\nExpected warnings: " + expectedWarnings +
                    "\nFound warnings: " + dc.warnings);
        }
    }

    class JavaSource extends SimpleJavaFileObject {

        String template = "import com.sun.tools.javac.api.*;\n" +
                          "import java.util.List;\n" +
                          "class Test {\n" +
                          "   static void test(Object o) {}\n" +
                          "   static void testArr(Object[] o) {}\n" +
                          "   #T \n #S #M { #B }\n" +
                          "}\n";

        String source;

        public JavaSource() {
            super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
            source = template.replace("#T", trustMe.anno).
                    replace("#S", suppressLevel.getSuppressAnno()).
                    replace("#M", sig.getSignature(modKind, methKind)).
                    replace("#B", body.body);
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return source;
        }
    }

    class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {

        EnumSet<WarningKind> warnings = EnumSet.noneOf(WarningKind.class);

        public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
            if (diagnostic.getKind() == Diagnostic.Kind.WARNING) {
                    if (diagnostic.getCode().contains("unsafe.use.varargs.param")) {
                        setWarning(WarningKind.UNSAFE_BODY);
                    } else if (diagnostic.getCode().contains("redundant.trustme")) {
                        setWarning(WarningKind.REDUNDANT_SAFEVARARGS);
                    }
            } else if (diagnostic.getKind() == Diagnostic.Kind.MANDATORY_WARNING &&
                    diagnostic.getCode().contains("varargs.non.reifiable.type")) {
                setWarning(WarningKind.UNSAFE_DECL);
            } else if (diagnostic.getKind() == Diagnostic.Kind.ERROR &&
                    diagnostic.getCode().contains("invalid.trustme")) {
                setWarning(WarningKind.MALFORMED_SAFEVARARGS);
            }
        }

        void setWarning(WarningKind wk) {
            if (!warnings.add(wk)) {
                throw new AssertionError("Duplicate warning of kind " + wk + " in source:\n" + source);
            }
        }

        boolean hasWarning(WarningKind wk) {
            return warnings.contains(wk);
        }
    }
}