289 lines
11 KiB
Java
289 lines
11 KiB
Java
/*
|
|
* 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();
|
|
}
|
|
|
|
}
|