/*
* Copyright (c) 2010, 2015, 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 6945418 6993978 8006694 7196160 8129962
* @summary Project Coin: Simplified Varargs Method Invocation
* temporarily workaround combo tests are causing time out in several platforms
* @library /tools/javac/lib
* @modules jdk.compiler/com.sun.tools.javac.api
* jdk.compiler/com.sun.tools.javac.code
* jdk.compiler/com.sun.tools.javac.comp
* jdk.compiler/com.sun.tools.javac.main
* jdk.compiler/com.sun.tools.javac.tree
* jdk.compiler/com.sun.tools.javac.util
* @build combo.ComboTestHelper
* @run main Warn4
*/
import java.io.IOException;
import java.util.Set;
import java.util.HashSet;
import javax.tools.Diagnostic;
import javax.tools.Diagnostic.Kind;
import javax.tools.JavaFileObject;
import combo.ComboInstance;
import combo.ComboParameter;
import combo.ComboTask.Result;
import combo.ComboTestHelper;
public class Warn4 extends ComboInstance<Warn4> {
final static Warning[] error = null;
final static Warning[] none = new Warning[] {};
final static Warning[] vararg = new Warning[] { Warning.VARARGS };
final static Warning[] unchecked = new Warning[] { Warning.UNCHECKED };
final static Warning[] both = new Warning[] { Warning.VARARGS, Warning.UNCHECKED };
enum Warning {
UNCHECKED("generic.array.creation"),
VARARGS("varargs.non.reifiable.type");
String key;
Warning(String key) {
this.key = key;
}
boolean isSuppressed(TrustMe trustMe, SourceLevel source,
SuppressLevel suppressLevelClient,
SuppressLevel suppressLevelDecl,
ModifierKind modKind) {
switch(this) {
case VARARGS:
return source.compareTo(SourceLevel.JDK_7) < 0 ||
suppressLevelDecl == SuppressLevel.UNCHECKED ||
trustMe == TrustMe.TRUST;
case UNCHECKED:
return suppressLevelClient == SuppressLevel.UNCHECKED ||
(trustMe == TrustMe.TRUST &&
(((modKind == ModifierKind.FINAL || modKind == ModifierKind.STATIC) &&
source.compareTo( SourceLevel.JDK_7) >= 0 ) ||
(modKind == ModifierKind.PRIVATE && source.compareTo( SourceLevel.JDK_9) >= 0 )));
}
SuppressLevel supLev = this == VARARGS ?
suppressLevelDecl :
suppressLevelClient;
return supLev == SuppressLevel.UNCHECKED ||
(trustMe == TrustMe.TRUST && modKind != ModifierKind.NONE);
}
}
enum SourceLevel {
JDK_6("6"),
JDK_7("7"),
JDK_9("9");
String sourceKey;
SourceLevel(String sourceKey) {
this.sourceKey = sourceKey;
}
}
enum TrustMe implements ComboParameter {
DONT_TRUST(""),
TRUST("@java.lang.SafeVarargs");
String anno;
TrustMe(String anno) {
this.anno = anno;
}
@Override
public String expand(String optParameter) {
return anno;
}
}
enum ModifierKind implements ComboParameter {
NONE(" "),
FINAL("final "),
STATIC("static "),
PRIVATE("private ");
String mod;
ModifierKind(String mod) {
this.mod = mod;
}
@Override
public String expand(String optParameter) {
return mod;
}
}
enum SuppressLevel implements ComboParameter {
NONE(""),
UNCHECKED("unchecked");
String lint;
SuppressLevel(String lint) {
this.lint = lint;
}
@Override
public String expand(String optParameter) {
return "@SuppressWarnings(\"" + lint + "\")";
}
}
enum Signature implements ComboParameter {
UNBOUND("void #NAME(List<?>#ARITY arg) { #BODY }",
new Warning[][] {none, none, none, none, error}),
INVARIANT_TVAR("<Z> void #NAME(List<Z>#ARITY arg) { #BODY }",
new Warning[][] {both, both, error, both, error}),
TVAR("<Z> void #NAME(Z#ARITY arg) { #BODY }",
new Warning[][] {both, both, both, both, vararg}),
INVARIANT("void #NAME(List<String>#ARITY arg) { #BODY }",
new Warning[][] {error, error, error, both, error}),
UNPARAMETERIZED("void #NAME(String#ARITY arg) { #BODY }",
new Warning[][] {error, error, error, error, none});
String template;
Warning[][] warnings;
Signature(String template, Warning[][] warnings) {
this.template = template;
this.warnings = warnings;
}
boolean isApplicableTo(Signature other) {
return warnings[other.ordinal()] != null;
}
boolean giveUnchecked(Signature other) {
return warnings[other.ordinal()] == unchecked ||
warnings[other.ordinal()] == both;
}
boolean giveVarargs(Signature other) {
return warnings[other.ordinal()] == vararg ||
warnings[other.ordinal()] == both;
}
@Override
public String expand(String optParameter) {
if (optParameter.equals("CLIENT")) {
return template.replaceAll("#ARITY", "")
.replaceAll("#NAME", "test")
.replaceAll("#BODY", "m(arg)");
} else {
return template.replaceAll("#ARITY", "...")
.replaceAll("#NAME", "m")
.replaceAll("#BODY", "");
}
}
}
public static void main(String... args) {
new ComboTestHelper<Warn4>()
.withFilter(Warn4::badTestFilter)
.withDimension("SOURCE", (x, level) -> x.sourceLevel = level, SourceLevel.values())
.withDimension("TRUSTME", (x, trustme) -> x.trustMe = trustme, TrustMe.values())
.withArrayDimension("SUPPRESS", (x, suppress, idx) -> x.suppress[idx] = suppress, 2, SuppressLevel.values())
.withDimension("MOD", (x, mod) -> x.modKind = mod, ModifierKind.values())
.withArrayDimension("MTH", (x, sig, idx) -> x.sigs[idx] = sig, 2, Signature.values())
.run(Warn4::new);
}
SourceLevel sourceLevel;
TrustMe trustMe;
SuppressLevel[] suppress = new SuppressLevel[2];
ModifierKind modKind;
Signature[] sigs = new Signature[2];
boolean badTestFilter() {
return sigs[0].isApplicableTo(sigs[1]);
}
final String template = "import java.util.List;\n" +
"class Test {\n" +
" #{TRUSTME} #{SUPPRESS[0]} #{MOD} #{MTH[0].VARARG}\n" +
" #{SUPPRESS[1]} #{MTH[1].CLIENT}\n" +
"}";
@Override
public void doWork() throws IOException {
check(newCompilationTask()
.withOption("-Xlint:unchecked")
.withOption("-source")
.withOption(sourceLevel.sourceKey)
.withSourceFromTemplate(template)
.analyze());
}
void check(Result<?> res) {
boolean[] warnArr = new boolean[] {sigs[0].giveUnchecked(sigs[1]),
sigs[0].giveVarargs(sigs[1])};
Set<Warning> warnings = new HashSet<>();
for (Diagnostic<? extends JavaFileObject> d : res.diagnosticsForKind(Kind.MANDATORY_WARNING)) {
if (d.getCode().contains(Warning.VARARGS.key)) {
warnings.add(Warning.VARARGS);
} else if(d.getCode().contains(Warning.UNCHECKED.key)) {
warnings.add(Warning.UNCHECKED);
}
}
boolean badOutput = false;
for (Warning wkind : Warning.values()) {
boolean isSuppressed = wkind.isSuppressed(trustMe, sourceLevel,
suppress[1], suppress[0], modKind);
badOutput |= (warnArr[wkind.ordinal()] && !isSuppressed) !=
warnings.contains(wkind);
}
if (badOutput) {
fail("invalid diagnostics for source:\n" +
res.compilationInfo() +
"\nExpected unchecked warning: " + warnArr[0] +
"\nExpected unsafe vararg warning: " + warnArr[1] +
"\nWarnings: " + warnings +
"\nSource level: " + sourceLevel);
}
}
}