545 lines
19 KiB
Java
545 lines
19 KiB
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 + "<<<");
|
|
}
|
|
}
|
|
}
|
|
|