/*
* Copyright (c) 2011, 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 7030150 7039931
* @summary Type inference for generic instance creation failed for formal type parameter
* @modules jdk.compiler
*/
import com.sun.source.util.JavacTask;
import java.net.URI;
import java.util.Arrays;
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 GenericConstructorAndDiamondTest {
enum BoundKind {
NO_BOUND(""),
STRING_BOUND("extends String"),
INTEGER_BOUND("extends Integer");
String boundStr;
private BoundKind(String boundStr) {
this.boundStr = boundStr;
}
boolean matches(TypeArgumentKind tak) {
switch (tak) {
case NONE: return true;
case STRING: return this != INTEGER_BOUND;
case INTEGER: return this != STRING_BOUND;
default: return false;
}
}
}
enum ConstructorKind {
NON_GENERIC("Foo(Object o) {}"),
GENERIC_NO_BOUND("<T> Foo(T t) {}"),
GENERIC_STRING_BOUND("<T extends String> Foo(T t) {}"),
GENERIC_INTEGER_BOUND("<T extends Integer> Foo(T t) {}");
String constrStr;
private ConstructorKind(String constrStr) {
this.constrStr = constrStr;
}
boolean matches(ArgumentKind ak) {
switch (ak) {
case STRING: return this != GENERIC_INTEGER_BOUND;
case INTEGER: return this != GENERIC_STRING_BOUND;
default: return false;
}
}
}
enum TypeArgArity {
ONE(1),
TWO(2),
THREE(3);
int n;
private TypeArgArity(int n) {
this.n = n;
}
}
enum TypeArgumentKind {
NONE(""),
STRING("String"),
INTEGER("Integer");
String typeargStr;
private TypeArgumentKind(String typeargStr) {
this.typeargStr = typeargStr;
}
String getArgs(TypeArgArity arity) {
if (this == NONE) return "";
else {
StringBuilder buf = new StringBuilder();
String sep = "";
for (int i = 0 ; i < arity.n ; i++) {
buf.append(sep);
buf.append(typeargStr);
sep = ",";
}
return "<" + buf.toString() + ">";
}
}
boolean matches(ArgumentKind ak) {
switch (ak) {
case STRING: return this != INTEGER;
case INTEGER: return this != STRING;
default: return false;
}
}
boolean matches(TypeArgumentKind other) {
switch (other) {
case STRING: return this != INTEGER;
case INTEGER: return this != STRING;
default: return true;
}
}
}
enum ArgumentKind {
STRING("\"\""),
INTEGER("1");
String argStr;
private ArgumentKind(String argStr) {
this.argStr = argStr;
}
}
public static void main(String... args) throws Exception {
//create default shared JavaCompiler - reused across multiple compilations
JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
try (StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null)) {
for (BoundKind boundKind : BoundKind.values()) {
for (ConstructorKind constructorKind : ConstructorKind.values()) {
for (TypeArgumentKind declArgKind : TypeArgumentKind.values()) {
for (TypeArgArity arity : TypeArgArity.values()) {
for (TypeArgumentKind useArgKind : TypeArgumentKind.values()) {
for (TypeArgumentKind diamondArgKind : TypeArgumentKind.values()) {
for (ArgumentKind argKind : ArgumentKind.values()) {
new GenericConstructorAndDiamondTest(boundKind, constructorKind,
declArgKind, arity, useArgKind, diamondArgKind, argKind).run(comp, fm);
}
}
}
}
}
}
}
}
}
BoundKind boundKind;
ConstructorKind constructorKind;
TypeArgumentKind declTypeArgumentKind;
TypeArgArity useTypeArgArity;
TypeArgumentKind useTypeArgumentKind;
TypeArgumentKind diamondTypeArgumentKind;
ArgumentKind argumentKind;
JavaSource source;
DiagnosticChecker diagChecker;
GenericConstructorAndDiamondTest(BoundKind boundKind, ConstructorKind constructorKind,
TypeArgumentKind declTypeArgumentKind, TypeArgArity useTypeArgArity,
TypeArgumentKind useTypeArgumentKind, TypeArgumentKind diamondTypeArgumentKind,
ArgumentKind argumentKind) {
this.boundKind = boundKind;
this.constructorKind = constructorKind;
this.declTypeArgumentKind = declTypeArgumentKind;
this.useTypeArgArity = useTypeArgArity;
this.useTypeArgumentKind = useTypeArgumentKind;
this.diamondTypeArgumentKind = diamondTypeArgumentKind;
this.argumentKind = argumentKind;
this.source = new JavaSource();
this.diagChecker = new DiagnosticChecker();
}
class JavaSource extends SimpleJavaFileObject {
String template = "class Foo<X #BK> {\n" +
"#CK\n" +
"}\n" +
"class Test {\n" +
"void test() {\n" +
"Foo#TA1 f = new #TA2 Foo<#TA3>(#A);\n" +
"}\n" +
"}\n";
String source;
public JavaSource() {
super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
source = template.replace("#BK", boundKind.boundStr).
replace("#CK", constructorKind.constrStr)
.replace("#TA1", declTypeArgumentKind.getArgs(TypeArgArity.ONE))
.replace("#TA2", useTypeArgumentKind.getArgs(useTypeArgArity))
.replace("#TA3", diamondTypeArgumentKind.typeargStr)
.replace("#A", argumentKind.argStr);
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return source;
}
}
void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
null, null, Arrays.asList(source));
ct.analyze();
check();
}
void check() {
boolean badActual = !constructorKind.matches(argumentKind);
boolean badArity = constructorKind != ConstructorKind.NON_GENERIC &&
useTypeArgumentKind != TypeArgumentKind.NONE &&
useTypeArgArity != TypeArgArity.ONE;
boolean badMethodTypeArg = constructorKind != ConstructorKind.NON_GENERIC &&
!useTypeArgumentKind.matches(argumentKind);
boolean badExplicitParams = (useTypeArgumentKind != TypeArgumentKind.NONE &&
diamondTypeArgumentKind == TypeArgumentKind.NONE) ||
!boundKind.matches(diamondTypeArgumentKind);
boolean badGenericType = !boundKind.matches(declTypeArgumentKind) ||
!diamondTypeArgumentKind.matches(declTypeArgumentKind);
boolean shouldFail = badActual || badArity ||
badMethodTypeArg || badExplicitParams || badGenericType;
if (shouldFail != diagChecker.errorFound) {
throw new Error("invalid diagnostics for source:\n" +
source.getCharContent(true) +
"\nFound error: " + diagChecker.errorFound +
"\nExpected error: " + shouldFail);
}
}
static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
boolean errorFound;
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
errorFound = true;
}
}
}
}