8145471: javac changes for enhanced deprecation
Reviewed-by: smarks, tbell, mcimadamore, jlahoda
/*
* 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 + "<<<");
}
}
}