Quelle  Removal.java

/*
 * Copyright (c) 2016, 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 8145471
 * @summary javac changes for enhanced deprecation
 * @library /tools/lib
 * @modules jdk.compiler/com.sun.tools.javac.api
 * @modules jdk.compiler/com.sun.tools.javac.main
 * @build toolbox.JavacTask toolbox.TestRunner toolbox.ToolBox
 * @run main Removal
 */

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import toolbox.JavacTask;
import toolbox.Task.Expect;
import toolbox.Task.OutputKind;
import toolbox.TestRunner;
import toolbox.ToolBox;

/*
 * From JEP 277, JDK-8085614
 *
 *        use site     |      API declaration site
 *        context      | not dep.   ord. dep.   term. dep.
 *                     +----------------------------------
 *        not dep.     |    N          W           W
 *                     |
 *        ord. dep.    |    N          N (2)       W (4)
 *                     |
 *        term. dep.   |    N          N (3)       W (5)
 */

public class Removal extends TestRunner {
    public static void main(String... args) throws Exception {
        Removal r = new Removal();
        r.runTests(m -> new Object[] { Paths.get(m.getName()) });
        r.report();
    }

    private final ToolBox tb = new ToolBox();
    private final Path libSrc = Paths.get("lib").resolve("src");
    private final Path libClasses = Paths.get("lib").resolve("classes");
    int testCount = 0;

    /**
     * Options that may be used during compilation.
     */
    enum Options {
        DEFAULT(),
        XLINT_DEPRECATED("-Xlint:deprecation"),
        XLINT_NO_REMOVAL("-Xlint:-removal");

        Options(String... opts) {
            this.opts = Arrays.asList(opts);
        }

        final List<String> opts;
    }

    /**
     * The kind of deprecation.
     */
    enum DeprKind {
        NONE("", null),
        DEPRECATED("@Deprecated ", "compiler.warn.has.been.deprecated"),
        REMOVAL("@Deprecated(forRemoval=true) ", "compiler.warn.has.been.deprecated.for.removal");
        DeprKind(String anno, String warn) {
            this.anno = anno;
            this.warn = warn;
        }
        final String anno;
        final String warn;
    }

    final String[] lib = {
        "package lib; public class Class {\n"
        + "    public static void method() { }\n"
        + "    @Deprecated public static void depMethod() { }\n"
        + "    @Deprecated(forRemoval=true) public static void remMethod() { }\n"
        + "    public static int field;\n"
        + "    @Deprecated public static int depField;\n"
        + "    @Deprecated(forRemoval=true) public static int remField;\n"
        + "}",
        "package lib; @Deprecated public class DepClass { }",
        "package lib; @Deprecated(forRemoval=true) public class RemClass { }"
    };

    /**
     * The kind of declaration to be referenced at the use site.
     */
    enum RefKind {
        CLASS("lib.%s c;", "Class", "DepClass", "RemClass"),
        METHOD("{ lib.Class.%s(); }", "method", "depMethod", "remMethod"),
        FIELD("int i = lib.Class.%s;", "field", "depField", "remField");

        RefKind(String template, String def, String dep, String rem) {
            fragments.put(DeprKind.NONE, String.format(template, def));
            fragments.put(DeprKind.DEPRECATED, String.format(template, dep));
            fragments.put(DeprKind.REMOVAL, String.format(template, rem));
        }

        String getFragment(DeprKind k) {
            return fragments.get(k);
        }

        private final Map<DeprKind, String> fragments = new EnumMap<>(DeprKind.class);
    }

    /**
     * Get source code for a reference to a possibly-deprecated item declared in a library.
     * @param refKind the kind of element (class, method, field) being referenced
     * @param declDeprKind the kind of deprecation on the declaration of the item being referenced
     * @param useDeprKind the kind of deprecation enclosing the use site
     * @return
     */
    static String getSource(RefKind refKind, DeprKind declDeprKind, DeprKind useDeprKind) {
        return "package p; "
                + useDeprKind.anno
                + "class Class { "
                + refKind.getFragment(declDeprKind)
                + " }";
    }

    private static final String NO_OUTPUT = null;

    public Removal() throws IOException {
        super(System.err);
        initLib();
    }

    void initLib() throws IOException {
        tb.writeJavaFiles(libSrc, lib);

        new JavacTask(tb)
                .outdir(Files.createDirectories(libClasses))
                .files(tb.findJavaFiles(libSrc))
                .run()
                .writeAll();
    }

    void report() {
        out.println(testCount + " test cases");
    }

    /*
     * Declaration site: not deprecated; use site: not deprecated
     * Options: default
     * Expect: no warnings
     */
    @Test
    public void test_DeclNone_UseNone(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.NONE, DeprKind.NONE),
                    Options.DEFAULT,
                    NO_OUTPUT);
        }
    }

    /*
     * Declaration site: not deprecated; use site: deprecated
     * Options: default
     * Expect: no warnings
     */
    @Test
    public void test_DeclNone_UseDeprecated(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.NONE, DeprKind.DEPRECATED),
                    Options.DEFAULT,
                    NO_OUTPUT);
        }
    }

    /*
     * Declaration site: not deprecated; use site: deprecated for removal
     * Options: default
     * Expect: no warnings
     */
    @Test
    public void test_DeclNone_UseRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.NONE, DeprKind.REMOVAL),
                    Options.DEFAULT,
                    NO_OUTPUT);
        }
    }

    /*
     * Declaration site: deprecated; use site: not deprecated
     * Options: default
     * Expect: deprecated note
     */
    @Test
    public void test_DeclDeprecated_UseNone_Default(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.DEPRECATED, DeprKind.NONE),
                    Options.DEFAULT,
                    "compiler.note.deprecated.filename: Class.java");
        }
    }

    /*
     * Declaration site: deprecated; use site: not deprecated
     * Options: -Xlint:deprecation
     * Expect: deprecated warning
     */
    @Test
    public void test_DeclDeprecated_UseNone_XlintDep(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            String error = "<unset>";
            switch (rk) {
                case CLASS:
                    error = "Class.java:1:29: compiler.warn.has.been.deprecated: lib.DepClass, lib";
                    break;

                case METHOD:
                    error = "Class.java:1:37: compiler.warn.has.been.deprecated: depMethod(), lib.Class";
                    break;

                case FIELD:
                    error = "Class.java:1:43: compiler.warn.has.been.deprecated: depField, lib.Class";
                    break;
            }

            test(base,
                    getSource(rk, DeprKind.DEPRECATED, DeprKind.NONE),
                    Options.XLINT_DEPRECATED,
                    error);
        }
    }

    /*
     * Declaration site: deprecated; use site: deprecated
     * Options: default
     * Expect: no warnings
     */
    @Test
    public void test_DeclDeprecated_UseDeprecated(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.DEPRECATED, DeprKind.DEPRECATED),
                    Options.DEFAULT,
                    NO_OUTPUT);
        }
    }

    /*
     * Declaration site: deprecated; use site: deprecated for removal
     * Options: default
     * Expect: no warnings
     */
    @Test
    public void test_DeclDeprecated_UseRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.DEPRECATED, DeprKind.REMOVAL),
                    Options.DEFAULT,
                    NO_OUTPUT);
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: not deprecated
     * Options: default
     * Expect: removal warning
     */
    @Test
    public void test_DeclRemoval_UseNone_Default(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            String error = "<unset>";
            switch (rk) {
                case CLASS:
                    error = "Class.java:1:29: compiler.warn.has.been.deprecated.for.removal: lib.RemClass, lib";
                    break;

                case METHOD:
                    error = "Class.java:1:37: compiler.warn.has.been.deprecated.for.removal: remMethod(), lib.Class";
                    break;

                case FIELD:
                    error = "Class.java:1:43: compiler.warn.has.been.deprecated.for.removal: remField, lib.Class";
                    break;
            }

            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.NONE),
                    Options.DEFAULT,
                    error);
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: not deprecated
     * Options: default, @SuppressWarnings("removal")
     * Expect: removal warning
     */
    @Test
    public void test_DeclRemoval_UseNone_SuppressRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            String source =
                    getSource(rk, DeprKind.REMOVAL, DeprKind.NONE)
                    .replace("class Class", "@SuppressWarnings(\"removal\") class Class");

            test(base,
                    source,
                    Options.DEFAULT,
                    null);
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: not deprecated
     * Options: -Xlint:-removal
     * Expect: removal note
     */
    @Test
    public void test_DeclRemoval_UseNone_XlintNoRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.NONE),
                    Options.XLINT_NO_REMOVAL,
                    "compiler.note.removal.filename: Class.java");
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: deprecated
     * Options: default
     * Expect: removal warning
     */
    @Test
    public void test_DeclRemoval_UseDeprecated_Default(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            String error = "<unset>";
            switch (rk) {
                case CLASS:
                    error = "Class.java:1:41: compiler.warn.has.been.deprecated.for.removal: lib.RemClass, lib";
                    break;

                case METHOD:
                    error = "Class.java:1:49: compiler.warn.has.been.deprecated.for.removal: remMethod(), lib.Class";
                    break;

                case FIELD:
                    error = "Class.java:1:55: compiler.warn.has.been.deprecated.for.removal: remField, lib.Class";
                    break;
            }

            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.DEPRECATED),
                    Options.DEFAULT,
                    error);
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: deprecated
     * Options: -Xlint:-removal
     * Expect: removal note
     */
    @Test
    public void test_DeclRemoval_UseDeprecated_XlintNoRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.DEPRECATED),
                    Options.XLINT_NO_REMOVAL,
                    "compiler.note.removal.filename: Class.java");
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: deprecated for removal
     * Options: default
     * Expect: removal warning
     */
    @Test
    public void test_DeclRemoval_UseRemoval_Default(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            String error = "<unset>";
            switch (rk) {
                case CLASS:
                    error = "Class.java:1:58: compiler.warn.has.been.deprecated.for.removal: lib.RemClass, lib";
                    break;

                case METHOD:
                    error = "Class.java:1:66: compiler.warn.has.been.deprecated.for.removal: remMethod(), lib.Class";
                    break;

                case FIELD:
                    error = "Class.java:1:72: compiler.warn.has.been.deprecated.for.removal: remField, lib.Class";
                    break;
            }

            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.REMOVAL),
                    Options.DEFAULT,
                    error);
        }
    }

    /*
     * Declaration site: deprecated for removal; use site: deprecated for removal
     * Options: -Xlint:-removal
     * Expect: removal note
     */
    @Test
    public void test_DeclRemoval_UseRemoval_XlintNoRemoval(Path base) throws IOException {
        for (RefKind rk : RefKind.values()) {
            test(base,
                    getSource(rk, DeprKind.REMOVAL, DeprKind.REMOVAL),
                    Options.XLINT_NO_REMOVAL,
                    "compiler.note.removal.filename: Class.java");
        }
    }

    /*
     * Additional special case:
     * there should not be any warnings for any reference in a type-import statement.
     */
    @Test
    public void test_UseImports(Path base) throws IOException {
        String source =
                "import lib.Class;\n"
                + "import lib.DepClass;\n"
                + "import lib.RemClass;\n"
                + "class C { }";
        for (Options o : Options.values()) {
            test(base, source, o, NO_OUTPUT);
        }
    }

    /**
     * Compile source code with given options, and check for expected output.
     * The compilation is done twice, first against the library in source form,
     * and then again, against the compiled library.
     * @param base base working directory
     * @param source the source code to be compiled
     * @param options the options for the compilation
     * @param expectText the expected output, or NO_OUTPUT, if none expected.
     * @throws IOException if an error occurs during the compilation
     */
    private void test(Path base, String source, Options options, String expectText) throws IOException {
        test(base.resolve("lib-source"), libSrc, source, options, expectText);
        test(base.resolve("lib-classes"), libClasses, source, options, expectText);
    }

    /**
     * Compile source code with given options against a given version of the library,
     * and check for expected output.
     * @param base base working directory
     * @param lib the directory containing the library, in either source or compiled form
     * @param source the source code to be compiled
     * @param options the options for the compilation
     * @param expectText the expected output, or NO_OUTPUT, if none expected.
     * @throws IOException if an error occurs during the compilation
     */
    private void test(Path base, Path lib, String source, Options options, String expectText)
            throws IOException {
        Expect expect = (expectText != null && expectText.contains("compiler.warn.")) ? Expect.FAIL : Expect.SUCCESS;
        test(base, lib, source, options.opts, expect, expectText);
    }

    /**
     * Compile source code with given options against a given version of the library,
     * and check for expected exit code and expected output.
     * @param base base working directory
     * @param lib the directory containing the library, in either source or compiled form
     * @param source the source code to be compiled
     * @param options the options for the compilation
     * @param expect the expected outcome of the compilation
     * @param expectText the expected output, or NO_OUTPUT, if none expected.
     * @throws IOException if an error occurs during the compilation
     */
    private void test(Path base, Path lib, String source, List<String> options,
            Expect expect, String expectText) throws IOException {
        testCount++;

        Path src = base.resolve("src");
        Path classes = Files.createDirectories(base.resolve("classes"));
        tb.writeJavaFiles(src, source);

        List<String> allOptions = new ArrayList<>();
        allOptions.add("-XDrawDiagnostics");
        allOptions.add("-Werror");
        allOptions.addAll(options);

        out.println("Source: " + source);
        out.println("Classpath: " + lib);
        out.println("Options: " + options.stream().collect(Collectors.joining(" ")));

        String log = new JavacTask(tb)
                .outdir(classes)
                .classpath(lib) // use classpath for libSrc or libClasses
                .files(tb.findJavaFiles(src))
                .options(allOptions.toArray(new String[0]))
                .run(expect)
                .writeAll()
                .getOutput(OutputKind.DIRECT);

        if (expectText == null) {
            if (!log.trim().isEmpty())
                error("Unexpected text found: >>>" + log + "<<<");
        } else {
            if (!log.contains(expectText))
                error("expected text not found: >>>" + expectText + "<<<");
        }
    }
}