540 lines
19 KiB
Java
540 lines
19 KiB
Java
/*
|
|
* Copyright (c) 2009, 2024, 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.
|
|
*/
|
|
|
|
import java.io.*;
|
|
import java.net.*;
|
|
import java.util.*;
|
|
import java.lang.constant.*;
|
|
import java.nio.file.Paths;
|
|
|
|
import java.lang.classfile.*;
|
|
import java.lang.classfile.attribute.*;
|
|
import java.lang.classfile.constantpool.*;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 6888367
|
|
* @summary classfile library parses signature attributes incorrectly
|
|
* @enablePreview
|
|
* @modules java.base/jdk.internal.classfile.impl
|
|
*/
|
|
|
|
/*
|
|
* This test is a pretty detailed test both of javac signature generation and classfile
|
|
* signature parsing. The first part of the test tests all the examples given in the
|
|
* second part of the test. Each example comes with one or two annotations, @Desc, @Sig,
|
|
* for the descriptor and signature of the annotated declaration. Annotations are
|
|
* provided whenever the annotated item is expected to have a corresponding value.
|
|
* Each annotation has two argument values. The first arg is the expected value of the
|
|
* descriptor/signature as found in the class file. This value is mostly for documentation
|
|
* purposes in reading the test. The second value is the rendering of the descriptor or
|
|
* signature using a custom Type visitor that explicitly includes an indication of the
|
|
* Type classes being used to represent the descriptor/signature. Thus we test
|
|
* that the descriptor/signature is being parsed into the expected type tree structure.
|
|
*/
|
|
public class T6888367 {
|
|
|
|
public static void main(String... args) throws Exception {
|
|
new T6888367().run();
|
|
}
|
|
|
|
public void run() throws Exception {
|
|
ClassModel cm = getClassFile("Test");
|
|
|
|
testFields(cm);
|
|
testMethods(cm);
|
|
testInnerClasses(cm); // recursive
|
|
|
|
if (errors > 0)
|
|
throw new Exception(errors + " errors found");
|
|
}
|
|
|
|
void testFields(ClassModel cm) throws Exception {
|
|
String cn = cm.thisClass().name().stringValue();
|
|
for (FieldModel fm: cm.fields()) {
|
|
test("field " + cn + "." + fm.fieldName(), fm.fieldTypeSymbol(), fm);
|
|
}
|
|
}
|
|
|
|
void testMethods(ClassModel cm) throws Exception {
|
|
String cn = cm.thisClass().name().stringValue();
|
|
for (MethodModel mm: cm.methods()) {
|
|
test("method " + cn + "." + mm.methodName(), mm.methodTypeSymbol(), mm);
|
|
}
|
|
}
|
|
|
|
void testInnerClasses(ClassModel cm) throws Exception {
|
|
InnerClassesAttribute ic =
|
|
cm.findAttribute(Attributes.innerClasses()).orElse(null);
|
|
assert ic != null;
|
|
for (InnerClassInfo info: ic.classes()) {
|
|
ClassEntry outerClass = info.outerClass().orElse(null);
|
|
if (outerClass == null || !outerClass.name().equalsString(cm.getClass().getName())) {
|
|
continue;
|
|
}
|
|
String innerClassName = info.innerClass().asInternalName();
|
|
ClassModel icm = getClassFile(innerClassName);
|
|
test("class " + innerClassName, null, icm);
|
|
testInnerClasses(icm);
|
|
}
|
|
}
|
|
|
|
void test(String name, ConstantDesc desc, AttributedElement m) {
|
|
AnnotValues d = getDescValue(m);
|
|
AnnotValues s = getSigValue(m);
|
|
if (d == null && s == null) // not a test field or method if no @Desc or @Sig given
|
|
return;
|
|
|
|
System.err.println(name);
|
|
SignatureAttribute sa = m.findAttribute(Attributes.signature()).orElse(null);
|
|
if (sa != null)
|
|
System.err.println(" signature: " + sa.signature());
|
|
|
|
switch (desc) {
|
|
case ClassDesc cDesc -> {
|
|
System.err.println(" descriptor: " + cDesc.descriptorString());
|
|
checkEqual(d.raw, cDesc.descriptorString());
|
|
Signature dt = Signature.of(cDesc);
|
|
checkEqual(d.type, tp.print(dt));
|
|
if (s != null || sa != null) {
|
|
if (s != null && sa != null) {
|
|
checkEqual(s.raw, sa.signature().stringValue());
|
|
Signature st = Signature.parseFrom(sa.signature().stringValue());
|
|
checkEqual(s.type, tp.print(st));
|
|
} else if (s != null)
|
|
error("@Sig annotation found but not Signature attribute");
|
|
else
|
|
error("Signature attribute found but no @Sig annotation");
|
|
}
|
|
}
|
|
case MethodTypeDesc mDesc -> {
|
|
System.err.println(" descriptor: " + mDesc.descriptorString());
|
|
checkEqual(d.raw, mDesc.descriptorString());
|
|
MethodSignature mdt = MethodSignature.of(mDesc);
|
|
checkEqual(d.type, tp.print(mdt));
|
|
if (s != null || sa != null) {
|
|
if (s != null && sa != null) {
|
|
checkEqual(s.raw, sa.signature().stringValue());
|
|
MethodSignature mst = MethodSignature.parseFrom(sa.signature().stringValue());
|
|
checkEqual(s.type, tp.print(mst));
|
|
} else if (s != null)
|
|
error("@Sig annotation found but not Signature attribute");
|
|
else
|
|
error("Signature attribute found but no @Sig annotation");
|
|
}
|
|
}
|
|
default -> throw new AssertionError();
|
|
}
|
|
System.err.println();
|
|
}
|
|
|
|
|
|
ClassModel getClassFile(String name) throws IOException, URISyntaxException {
|
|
URL rsc = getClass().getResource(name + ".class");
|
|
assert rsc != null;
|
|
return ClassFile.of().parse(Paths.get(rsc.toURI()));
|
|
}
|
|
|
|
AnnotValues getDescValue(AttributedElement m) {
|
|
return getAnnotValues(Desc.class.getName(), m);
|
|
}
|
|
|
|
AnnotValues getSigValue(AttributedElement m) {
|
|
return getAnnotValues(Sig.class.getName(), m);
|
|
}
|
|
|
|
static class AnnotValues {
|
|
AnnotValues(String raw, String type) {
|
|
this.raw = raw;
|
|
this.type = type;
|
|
}
|
|
final String raw;
|
|
final String type;
|
|
}
|
|
|
|
AnnotValues getAnnotValues(String annotName, AttributedElement m) {
|
|
RuntimeInvisibleAnnotationsAttribute annots = m.findAttribute(Attributes.runtimeInvisibleAnnotations()).orElse(null);
|
|
if (annots != null) {
|
|
for (Annotation a: annots.annotations()) {
|
|
if (a.classSymbol().descriptorString().equals("L" + annotName + ";")) {
|
|
String pv0 = ((AnnotationValue.OfString) a.elements().get(0).value()).stringValue();
|
|
String pv1 = ((AnnotationValue.OfString) a.elements().get(1).value()).stringValue();
|
|
return new AnnotValues(pv0, pv1);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
|
|
}
|
|
|
|
void checkEqual(String expect, String found) {
|
|
if (!(Objects.equals(expect, found))) {
|
|
System.err.println("expected: " + expect);
|
|
System.err.println(" found: " + found);
|
|
error("unexpected values found");
|
|
}
|
|
}
|
|
|
|
void error(String msg) {
|
|
System.err.println("error: " + msg);
|
|
errors++;
|
|
}
|
|
|
|
int errors;
|
|
|
|
TypePrinter tp = new TypePrinter();
|
|
|
|
class TypePrinter {
|
|
<T> String print(T t) {
|
|
switch (t) {
|
|
case Signature.BaseTypeSig type -> {
|
|
return visitSimpleType(type);
|
|
}
|
|
case Signature.ArrayTypeSig type -> {
|
|
return visitArrayType(type);
|
|
}
|
|
case Signature.ClassTypeSig type -> {
|
|
return visitClassType(type);
|
|
}
|
|
case ClassSignature type -> {
|
|
return visitClassSigType(type);
|
|
}
|
|
case MethodSignature type -> {
|
|
return visitMethodType(type);
|
|
}
|
|
case Signature.TypeVarSig type -> {
|
|
return "S{" + type.identifier() + "}"; //Consider the TypeVarSig as Simple Type
|
|
}
|
|
default -> {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
<T> String print(String pre, List<T> ts, String post) {
|
|
if (ts == null)
|
|
return null;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(pre);
|
|
String sep = "";
|
|
for (T t: ts) {
|
|
sb.append(sep);
|
|
switch (t) {
|
|
case Signature sig -> sb.append(print(sig));
|
|
case Signature.TypeParam pSig -> sb.append(visitTypeParamType(pSig));
|
|
case Signature.TypeArg aSig -> sb.append(visitWildcardType(aSig));
|
|
default -> throw new AssertionError();
|
|
}
|
|
sep = ",";
|
|
}
|
|
sb.append(post);
|
|
return sb.toString();
|
|
}
|
|
|
|
public String visitSimpleType(Signature.BaseTypeSig type) {
|
|
return "S{" + type.baseType() + "}";
|
|
}
|
|
|
|
public String visitArrayType(Signature.ArrayTypeSig type) {
|
|
return "A{" + print(type.componentSignature()) + "}";
|
|
}
|
|
|
|
public String visitMethodType(MethodSignature type) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("M{");
|
|
if (!type.typeParameters().isEmpty())
|
|
sb.append(print("<", type.typeParameters(), ">"));
|
|
sb.append(print(type.result()));
|
|
sb.append(print("(", type.arguments(), ")"));
|
|
if (!type.throwableSignatures().isEmpty())
|
|
sb.append(print("", type.throwableSignatures(), ""));
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public String visitClassSigType(ClassSignature type) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("CS{");
|
|
if (!type.typeParameters().isEmpty())
|
|
sb.append(print("<", type.typeParameters(), ">"));
|
|
sb.append(print(type.superclassSignature()));
|
|
if (!type.superinterfaceSignatures().isEmpty())
|
|
sb.append(print("i(", type.superinterfaceSignatures(), ")"));
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public String visitClassType(Signature.ClassTypeSig type) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("C{");
|
|
if (type.outerType().isPresent()) {
|
|
sb.append(print(type.outerType().get()));
|
|
sb.append(".");
|
|
}
|
|
sb.append(type.className());
|
|
if (!type.typeArgs().isEmpty())
|
|
sb.append(print("<", type.typeArgs(), ">"));
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public String visitTypeParamType(Signature.TypeParam type) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("TA{");
|
|
sb.append(type.identifier());
|
|
if (type.classBound().isPresent()) {
|
|
sb.append(":c");
|
|
sb.append(print(type.classBound().get()));
|
|
}
|
|
if (!type.interfaceBounds().isEmpty())
|
|
sb.append(print(":i", type.interfaceBounds(), ""));
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public String visitWildcardType(Signature.TypeArg type) {
|
|
return switch (type) {
|
|
case Signature.TypeArg.Unbounded _ -> "W{?}";
|
|
case Signature.TypeArg.Bounded b -> switch (b.wildcardIndicator()) {
|
|
case EXTENDS -> "W{e," + print(b.boundType()) + "}";
|
|
case SUPER -> "W{s," + print(b.boundType()) + "}";
|
|
case NONE -> print(b.boundType());
|
|
};
|
|
};
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
@interface Desc {
|
|
String d();
|
|
String t();
|
|
}
|
|
|
|
@interface Sig {
|
|
String s();
|
|
String t();
|
|
}
|
|
|
|
class Clss { }
|
|
interface Intf { }
|
|
class GenClss<T> { }
|
|
|
|
class Test {
|
|
// fields
|
|
|
|
@Desc(d="Z", t="S{Z}")
|
|
boolean z;
|
|
|
|
@Desc(d="B", t="S{B}")
|
|
byte b;
|
|
|
|
@Desc(d="C", t="S{C}")
|
|
char c;
|
|
|
|
@Desc(d="D", t="S{D}")
|
|
double d;
|
|
|
|
@Desc(d="F", t="S{F}")
|
|
float f;
|
|
|
|
@Desc(d="I", t="S{I}")
|
|
int i;
|
|
|
|
@Desc(d="J", t="S{J}")
|
|
long l;
|
|
|
|
@Desc(d="S", t="S{S}")
|
|
short s;
|
|
|
|
@Desc(d="LClss;", t="C{Clss}")
|
|
Clss clss;
|
|
|
|
@Desc(d="LIntf;", t="C{Intf}")
|
|
Intf intf;
|
|
|
|
@Desc(d="[I", t="A{S{I}}")
|
|
int[] ai;
|
|
|
|
@Desc(d="[LClss;", t="A{C{Clss}}")
|
|
Clss[] aClss;
|
|
|
|
@Desc(d="LGenClss;", t="C{GenClss}")
|
|
@Sig(s="LGenClss<LClss;>;", t="C{GenClss<C{Clss}>}")
|
|
GenClss<Clss> genClass;
|
|
|
|
// methods, return types
|
|
|
|
@Desc(d="()V", t="M{S{V}()}")
|
|
void mv0() { }
|
|
|
|
@Desc(d="()I", t="M{S{I}()}")
|
|
int mi0() { return 0; }
|
|
|
|
@Desc(d="()LClss;", t="M{C{Clss}()}")
|
|
Clss mclss0() { return null; }
|
|
|
|
@Desc(d="()[I", t="M{A{S{I}}()}")
|
|
int[] mai0() { return null; }
|
|
|
|
@Desc(d="()[LClss;", t="M{A{C{Clss}}()}")
|
|
Clss[] maClss0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="()LGenClss<LClss;>;", t="M{C{GenClss<C{Clss}>}()}")
|
|
GenClss<Clss> mgenClss0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="()LGenClss<*>;", t="M{C{GenClss<W{?}>}()}")
|
|
GenClss<?> mgenClssW0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="()LGenClss<+LClss;>;", t="M{C{GenClss<W{e,C{Clss}}>}()}")
|
|
GenClss<? extends Clss> mgenClssWExtClss0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="()LGenClss<-LClss;>;", t="M{C{GenClss<W{s,C{Clss}}>}()}")
|
|
GenClss<? super Clss> mgenClssWSupClss0() { return null; }
|
|
|
|
@Desc(d="()Ljava/lang/Object;", t="M{C{java/lang/Object}()}")
|
|
@Sig(s="<T:Ljava/lang/Object;>()TT;", t="M{<TA{T:cC{java/lang/Object}}>S{T}()}")
|
|
<T> T mt0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="<T:Ljava/lang/Object;>()LGenClss<+TT;>;",
|
|
t="M{<TA{T:cC{java/lang/Object}}>C{GenClss<W{e,S{T}}>}()}")
|
|
<T> GenClss<? extends T> mgenClssWExtT0() { return null; }
|
|
|
|
@Desc(d="()LGenClss;", t="M{C{GenClss}()}")
|
|
@Sig(s="<T:Ljava/lang/Object;>()LGenClss<-TT;>;", t="M{<TA{T:cC{java/lang/Object}}>C{GenClss<W{s,S{T}}>}()}")
|
|
<T> GenClss<? super T> mgenClssWSupT0() { return null; }
|
|
|
|
// methods, arg types
|
|
|
|
@Desc(d="(I)V", t="M{S{V}(S{I})}")
|
|
void mi1(int arg) { }
|
|
|
|
@Desc(d="(LClss;)V", t="M{S{V}(C{Clss})}")
|
|
void mclss1(Clss arg) { }
|
|
|
|
@Desc(d="([I)V", t="M{S{V}(A{S{I}})}")
|
|
void mai1(int[] arg) { }
|
|
|
|
@Desc(d="([LClss;)V", t="M{S{V}(A{C{Clss}})}")
|
|
void maClss1(Clss[] arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="(LGenClss<LClss;>;)V", t="M{S{V}(C{GenClss<C{Clss}>})}")
|
|
void mgenClss1(GenClss<Clss> arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="(LGenClss<*>;)V", t="M{S{V}(C{GenClss<W{?}>})}")
|
|
void mgenClssW1(GenClss<?> arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="(LGenClss<+LClss;>;)V", t="M{S{V}(C{GenClss<W{e,C{Clss}}>})}")
|
|
void mgenClssWExtClss1(GenClss<? extends Clss> arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="(LGenClss<-LClss;>;)V", t="M{S{V}(C{GenClss<W{s,C{Clss}}>})}")
|
|
void mgenClssWSupClss1(GenClss<? super Clss> arg) { }
|
|
|
|
@Desc(d="(Ljava/lang/Object;)V", t="M{S{V}(C{java/lang/Object})}")
|
|
@Sig(s="<T:Ljava/lang/Object;>(TT;)V",
|
|
t="M{<TA{T:cC{java/lang/Object}}>S{V}(S{T})}")
|
|
<T> void mt1(T arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="<T:Ljava/lang/Object;>(LGenClss<+TT;>;)V",
|
|
t="M{<TA{T:cC{java/lang/Object}}>S{V}(C{GenClss<W{e,S{T}}>})}")
|
|
<T> void mgenClssWExtT1(GenClss<? extends T> arg) { }
|
|
|
|
@Desc(d="(LGenClss;)V", t="M{S{V}(C{GenClss})}")
|
|
@Sig(s="<T:Ljava/lang/Object;>(LGenClss<-TT;>;)V",
|
|
t="M{<TA{T:cC{java/lang/Object}}>S{V}(C{GenClss<W{s,S{T}}>})}")
|
|
<T> void mgenClssWSupT1(GenClss<? super T> arg) { }
|
|
|
|
// methods, throws
|
|
|
|
@Desc(d="()V", t="M{S{V}()}")
|
|
void m_E() throws Exception { }
|
|
|
|
@Desc(d="()V", t="M{S{V}()}")
|
|
@Sig(s="<T:Ljava/lang/Throwable;>()V^TT;",
|
|
t="M{<TA{T:cC{java/lang/Throwable}}>S{V}()S{T}}")
|
|
<T extends Throwable> void m_T() throws T { }
|
|
|
|
// inner classes
|
|
|
|
static class X {
|
|
// no sig
|
|
class P { }
|
|
|
|
@Sig(s="<TQ:Ljava/lang/Object;>LTest$X$P;",
|
|
t="CS{<TA{TQ:cC{java/lang/Object}}>C{Test$X$P}}")
|
|
class Q<TQ> extends P { }
|
|
|
|
@Sig(s="<TR:Ljava/lang/Object;>LTest$X$Q<TTR;>;",
|
|
t="CS{<TA{TR:cC{java/lang/Object}}>C{Test$X$Q<S{TR}>}}")
|
|
class R<TR> extends Q<TR> { }
|
|
}
|
|
|
|
@Sig(s="<TY:Ljava/lang/Object;>Ljava/lang/Object;",
|
|
t="CS{<TA{TY:cC{java/lang/Object}}>C{java/lang/Object}}")
|
|
static class Y<TY> {
|
|
// no sig
|
|
class P { }
|
|
|
|
@Sig(s="<TQ:Ljava/lang/Object;>LTest$Y<TTY;>.P;",
|
|
t="CS{<TA{TQ:cC{java/lang/Object}}>C{C{Test$Y<S{TY}>}.P}}")
|
|
class Q<TQ> extends P { }
|
|
|
|
@Sig(s="<TR:Ljava/lang/Object;>LTest$Y<TTY;>.Q<TTR;>;",
|
|
t="CS{<TA{TR:cC{java/lang/Object}}>C{C{Test$Y<S{TY}>}.Q<S{TR}>}}")
|
|
class R<TR> extends Q<TR> {
|
|
// no sig
|
|
class R1 { }
|
|
|
|
@Sig(s="<TR2:Ljava/lang/Object;>LTest$Y<TTY;>.R<TTR;>.R1;",
|
|
t="CS{<TA{TR2:cC{java/lang/Object}}>C{C{C{Test$Y<S{TY}>}.R<S{TR}>}.R1}}")
|
|
class R2<TR2> extends R1 { }
|
|
}
|
|
|
|
@Sig(s="LTest$Y<TTY;>.Q<TTY;>;", t="C{C{Test$Y<S{TY}>}.Q<S{TY}>}")
|
|
class S extends Q<TY> {
|
|
// no sig
|
|
class S1 { }
|
|
|
|
@Sig(s="<TS2:Ljava/lang/Object;>LTest$Y<TTY;>.S.S1;",
|
|
t="CS{<TA{TS2:cC{java/lang/Object}}>C{C{C{Test$Y<S{TY}>}.S}.S1}}")
|
|
class S2<TS2> extends S1 { }
|
|
|
|
@Sig(s="LTest$Y<TTY;>.S.S2<TTY;>;",
|
|
t="C{C{C{Test$Y<S{TY}>}.S}.S2<S{TY}>}")
|
|
class S3 extends S2<TY> { }
|
|
}
|
|
}
|
|
}
|
|
|
|
|