/*
* Copyright (c) 2013, 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 7118412
* @summary Shadowing of type-variables vs. member types
* @modules jdk.compiler
*/
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
public class ShadowingTest {
// We generate a method "test" that tries to call T.<something,
// depending on the value of MethodCall>. This controls whether
// "test" is static or not.
private enum MethodContext {
STATIC("static "),
INSTANCE("");
public final String methodcontext;
MethodContext(final String methodcontext) {
this.methodcontext = methodcontext;
}
}
// These control whether or not a type parameter, method type
// parameter, or inner class get declared (and in the case of
// inner classes, whether it's static or not.
private enum MethodTypeParameterDecl {
NO(""),
YES("<T extends Number> ");
public final String tyvar;
MethodTypeParameterDecl(final String tyvar) {
this.tyvar = tyvar;
}
}
private enum InsideDef {
NONE(""),
STATIC("static class T { public void inner() {} }\n"),
INSTANCE("class T { public void inner() {} }\n");
public final String instancedef;
InsideDef(final String instancedef) {
this.instancedef = instancedef;
}
}
private enum TypeParameterDecl {
NO(""),
YES("<T extends Collection>");
public final String tyvar;
TypeParameterDecl(final String tyvar) {
this.tyvar = tyvar;
}
}
// Represents what method we try to call. This is a way of
// checking which T we're seeing.
private enum MethodCall {
// Method type variables extend Number, so we have intValue
METHOD_TYPEVAR("intValue"),
// The inner class declaration has a method called "inner"
INNER_CLASS("inner"),
// The class type variables extend Collection, so we call iterator
TYPEVAR("iterator"),
// The outer class declaration has a method called "outer"
OUTER_CLASS("outer");
public final String methodcall;
MethodCall(final String methodcall) {
this.methodcall = methodcall;
}
}
public boolean succeeds(final MethodCall call,
final MethodTypeParameterDecl mtyvar,
final MethodContext ctx,
final InsideDef inside,
final TypeParameterDecl tyvar) {
switch(call) {
// We want to resolve to the method type variable
case METHOD_TYPEVAR: switch(mtyvar) {
// If the method type variable exists, then T will
// resolve to it, and we'll have intValue.
case YES: return true;
// Otherwise, this cannot succeed.
default: return false;
}
// We want to resolve to the inner class
case INNER_CLASS: switch(mtyvar) {
// The method type parameter will shadow the inner
// class, so there can't be one.
case NO: switch(ctx) {
// If we're not static, then either one should succeed.
case INSTANCE: switch(inside) {
case INSTANCE:
case STATIC:
return true;
default: return false;
}
case STATIC: switch(inside) {
// If we are static, and the inner class is
// static, then we also succeed, because we
// can't see the type variable.
case STATIC: return true;
case INSTANCE: switch(tyvar) {
// If we're calling from a non-static
// context, there can't be a class type
// variable, because that will shadow the
// static inner class definition.
case NO: return true;
default: return false;
}
// If the inner class isn't declared, we can't
// see it.
default: return false;
}
// Can't get here.
default: return false;
}
default: return false;
}
// We want to resolve to the class type parameter
case TYPEVAR: switch(mtyvar) {
// We can't have a method type parameter, as that would
// shadow the class type parameter
case NO: switch(ctx) {
case INSTANCE: switch(inside) {
// We have to be in an instance context. If
// we're static, we can't see the type
// variable.
case NONE: switch(tyvar) {
// Obviously, the type parameter has to be declared.
case YES: return true;
default: return false;
}
default: return false;
}
default: return false;
}
default: return false;
}
// We want to resolve to the outer class
case OUTER_CLASS: switch(mtyvar) {
case NO: switch(inside) {
case NONE: switch(tyvar) {
// Basically, nothing else can be declared, or
// else we can't see it. Even if our context
// is static, the compiler will complain if
// non-static T's exist, because they will
// shadow the outer class.
case NO: return true;
default: return false;
}
default: return false;
}
default: return false;
}
}
return false;
}
private static final File classesdir = new File("7118412");
private int errors = 0;
private int dirnum = 0;
private void doTest(final MethodTypeParameterDecl mtyvar,
final TypeParameterDecl tyvar,
final InsideDef insidedef, final MethodContext ctx,
final MethodCall call)
throws IOException {
final String content = "import java.util.Collection;\n" +
"class Test" + tyvar.tyvar + " {\n" +
" " + insidedef.instancedef +
" " + ctx.methodcontext + mtyvar.tyvar + "void test(T t) { t." +
call.methodcall + "(); }\n" +
"}\n" +
"class T { void outer() {} }\n";
final File dir = new File(classesdir, "" + dirnum);
final File Test_java = writeFile(dir, "Test.java", content);
dirnum++;
if(succeeds(call, mtyvar, ctx, insidedef, tyvar)) {
if(!assert_compile_succeed(Test_java))
System.err.println("Failed file:\n" + content);
}
else {
if(!assert_compile_fail(Test_java))
System.err.println("Failed file:\n" + content);
}
}
private void run() throws Exception {
classesdir.mkdir();
for(MethodTypeParameterDecl mtyvar : MethodTypeParameterDecl.values())
for(TypeParameterDecl tyvar : TypeParameterDecl.values())
for(InsideDef insidedef : InsideDef.values())
for(MethodContext ctx : MethodContext.values())
for(MethodCall methodcall : MethodCall.values())
doTest(mtyvar, tyvar, insidedef, ctx, methodcall);
if (errors != 0)
throw new Exception("ShadowingTest test failed with " +
errors + " errors.");
}
private boolean assert_compile_fail(final File file) {
final String filename = file.getPath();
final String[] args = { filename };
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw);
final int rc = com.sun.tools.javac.Main.compile(args, pw);
pw.close();
if (rc == 0) {
System.err.println("Compilation of " + file.getName() +
" didn't fail as expected.");
errors++;
return false;
} else return true;
}
private boolean assert_compile_succeed(final File file) {
final String filename = file.getPath();
final String[] args = { filename };
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw);
final int rc = com.sun.tools.javac.Main.compile(args, pw);
pw.close();
if (rc != 0) {
System.err.println("Compilation of " + file.getName() +
" didn't succeed as expected. Output:");
System.err.println(sw.toString());
errors++;
return false;
} else return true;
}
private File writeFile(final File dir,
final String path,
final String body) throws IOException {
final File f = new File(dir, path);
f.getParentFile().mkdirs();
final FileWriter out = new FileWriter(f);
out.write(body);
out.close();
return f;
}
public static void main(String... args) throws Exception {
new ShadowingTest().run();
}
}