Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Backport jdk 8341779 #3038

Draft
wants to merge 4 commits into
base: master
Choose a base branch
from
Draft

Backport jdk 8341779 #3038

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
00b869c
Backport de6667cf11aa59d1bab78ae5fb235ea0b901d5c4
cushon Nov 11, 2024
7a7d912
Fix backport for changes in TypeMetadata API
cushon Nov 11, 2024
6285661
Improve test coverage for class loading elements with annotations of …
cushon Nov 11, 2024
4965dd9
Disable handling of annotations with different retention at the same …
cushon Nov 11, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
305 changes: 305 additions & 0 deletions src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,7 +36,9 @@
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.IntFunction;
import java.util.function.Predicate;

import javax.lang.model.element.Modifier;
import javax.lang.model.element.NestingKind;
Expand Down Expand Up @@ -2185,12 +2187,315 @@ public void run() {
currentClassFile = classFile;
List<Attribute.TypeCompound> newList = deproxyTypeCompoundList(proxies);
sym.setTypeAttributes(newList.prependList(sym.getRawTypeAttributes()));
addTypeAnnotationsToSymbol(sym, newList);
} finally {
currentClassFile = previousClassFile;
}
}
}

/**
* Rewrites types in the given symbol to include type annotations.
*
* <p>The list of type annotations includes annotations for all types in the signature of the
* symbol. Associating the annotations with the correct type requires interpreting the JVMS
* 4.7.20-A target_type to locate the correct type to rewrite, and then interpreting the JVMS
* 4.7.20.2 type_path to associate the annotation with the correct contained type.
*/
private static void addTypeAnnotationsToSymbol(
Symbol s, List<Attribute.TypeCompound> attributes) {
new TypeAnnotationSymbolVisitor(attributes).visit(s, null);
}

private static class TypeAnnotationSymbolVisitor
extends Types.DefaultSymbolVisitor<Void, Void> {

private final List<Attribute.TypeCompound> attributes;

private TypeAnnotationSymbolVisitor(List<Attribute.TypeCompound> attributes) {
this.attributes = attributes;
}

@Override
public Void visitClassSymbol(Symbol.ClassSymbol s, Void unused) {
ClassType t = (ClassType) s.type;
int i = 0;
ListBuffer<Type> interfaces = new ListBuffer<>();
for (Type itf : t.interfaces_field) {
interfaces.add(addTypeAnnotations(itf, classExtends(i++)));
}
t.interfaces_field = interfaces.toList();
t.supertype_field = addTypeAnnotations(t.supertype_field, classExtends(65535));
if (t.typarams_field != null) {
t.typarams_field =
rewriteTypeParameters(
t.typarams_field, TargetType.CLASS_TYPE_PARAMETER_BOUND);
}
return null;
}

@Override
public Void visitMethodSymbol(Symbol.MethodSymbol s, Void unused) {
Type t = s.type;
if (t.hasTag(TypeTag.FORALL)) {
Type.ForAll fa = (Type.ForAll) t;
fa.tvars = rewriteTypeParameters(fa.tvars, TargetType.METHOD_TYPE_PARAMETER_BOUND);
t = fa.qtype;
}
MethodType mt = (MethodType) t;
ListBuffer<Type> argtypes = new ListBuffer<>();
int i = 0;
for (Symbol.VarSymbol param : s.params) {
param.type = addTypeAnnotations(param.type, methodFormalParameter(i++));
argtypes.add(param.type);
}
mt.argtypes = argtypes.toList();
ListBuffer<Type> thrown = new ListBuffer<>();
i = 0;
for (Type thrownType : mt.thrown) {
thrown.add(addTypeAnnotations(thrownType, thrownType(i++)));
}
mt.thrown = thrown.toList();
mt.restype = addTypeAnnotations(mt.restype, TargetType.METHOD_RETURN);
if (mt.recvtype != null) {
mt.recvtype = addTypeAnnotations(mt.recvtype, TargetType.METHOD_RECEIVER);
}
return null;
}

@Override
public Void visitVarSymbol(Symbol.VarSymbol s, Void unused) {
s.type = addTypeAnnotations(s.type, TargetType.FIELD);
return null;
}

@Override
public Void visitSymbol(Symbol s, Void unused) {
return null;
}

private List<Type> rewriteTypeParameters(List<Type> tvars, TargetType boundType) {
ListBuffer<Type> tvarbuf = new ListBuffer<>();
int typeVariableIndex = 0;
for (Type tvar : tvars) {
Type bound = tvar.getUpperBound();
if (bound.isCompound()) {
ClassType ct = (ClassType) bound;
int boundIndex = 0;
if (ct.supertype_field != null) {
ct.supertype_field =
addTypeAnnotations(
ct.supertype_field,
typeParameterBound(
boundType, typeVariableIndex, boundIndex++));
}
ListBuffer<Type> itfbuf = new ListBuffer<>();
for (Type itf : ct.interfaces_field) {
itfbuf.add(
addTypeAnnotations(
itf,
typeParameterBound(
boundType, typeVariableIndex, boundIndex++)));
}
ct.interfaces_field = itfbuf.toList();
} else {
bound =
addTypeAnnotations(
bound,
typeParameterBound(
boundType,
typeVariableIndex,
bound.isInterface() ? 1 : 0));
}
((TypeVar) tvar).setUpperBound(bound);
tvarbuf.add(tvar);
typeVariableIndex++;
}
return tvarbuf.toList();
}

private Type addTypeAnnotations(Type type, TargetType targetType) {
return addTypeAnnotations(type, pos -> pos.type == targetType);
}

private Type addTypeAnnotations(Type type, Predicate<TypeAnnotationPosition> filter) {
Assert.checkNonNull(type);

// Find type annotations that match the given target type
ListBuffer<Attribute.TypeCompound> filtered = new ListBuffer<>();
for (Attribute.TypeCompound attribute : this.attributes) {
if (filter.test(attribute.position)) {
filtered.add(attribute);
}
}
if (filtered.isEmpty()) {
return type;
}

// Group the matching annotations by their type path. Each group of annotations will be
// added to a type at that location.
Map<List<TypeAnnotationPosition.TypePathEntry>, ListBuffer<Attribute.TypeCompound>>
attributesByPath = new HashMap<>();
for (Attribute.TypeCompound attribute : filtered.toList()) {
attributesByPath
.computeIfAbsent(attribute.position.location, k -> new ListBuffer<>())
.add(attribute);
}

// Search the structure of the type to find the contained types at each type path
Map<Type, List<Attribute.TypeCompound>> attributesByType = new HashMap<>();
new TypeAnnotationLocator(attributesByPath, attributesByType).visit(type, List.nil());

// Rewrite the type and add the annotations
type = new TypeAnnotationTypeMapping(attributesByType).visit(type, null);
Assert.check(attributesByType.isEmpty(), "Failed to apply annotations to types");

return type;
}

private static Predicate<TypeAnnotationPosition> typeParameterBound(
TargetType targetType, int parameterIndex, int boundIndex) {
return pos ->
pos.type == targetType
&& pos.parameter_index == parameterIndex
&& pos.bound_index == boundIndex;
}

private static Predicate<TypeAnnotationPosition> methodFormalParameter(int index) {
return pos ->
pos.type == TargetType.METHOD_FORMAL_PARAMETER && pos.parameter_index == index;
}

private static Predicate<TypeAnnotationPosition> thrownType(int index) {
return pos -> pos.type == TargetType.THROWS && pos.type_index == index;
}

private static Predicate<TypeAnnotationPosition> classExtends(int index) {
return pos -> pos.type == TargetType.CLASS_EXTENDS && pos.type_index == index;
}
}

/**
* Visit all contained types, assembling a type path to represent the current location, and
* record the types at each type path that need to be annotated.
*/
private static class TypeAnnotationLocator
extends Types.DefaultTypeVisitor<Void, List<TypeAnnotationPosition.TypePathEntry>> {
private final Map<List<TypeAnnotationPosition.TypePathEntry>,
ListBuffer<Attribute.TypeCompound>> attributesByPath;
private final Map<Type, List<Attribute.TypeCompound>> attributesByType;

private TypeAnnotationLocator(
Map<List<TypeAnnotationPosition.TypePathEntry>, ListBuffer<Attribute.TypeCompound>>
attributesByPath,
Map<Type, List<Attribute.TypeCompound>> attributesByType) {
this.attributesByPath = attributesByPath;
this.attributesByType = attributesByType;
}

@Override
public Void visitClassType(ClassType t, List<TypeAnnotationPosition.TypePathEntry> path) {
// As described in JVMS 4.7.20.2, type annotations on nested types are located with
// 'left-to-right' steps starting on 'the outermost part of the type for which a type
// annotation is admissible'. So the current path represents the outermost containing
// type of the type being visited, and we add type path steps for every contained nested
// type.
List<ClassType> enclosing = List.nil();
for (Type curr = t;
curr != null && curr != Type.noType;
curr = curr.getEnclosingType()) {
enclosing = enclosing.prepend((ClassType) curr);
}
for (ClassType te : enclosing) {
if (te.typarams_field != null) {
int i = 0;
for (Type typaram : te.typarams_field) {
visit(typaram, path.append(new TypeAnnotationPosition.TypePathEntry(
TypeAnnotationPosition.TypePathEntryKind.TYPE_ARGUMENT, i++)));
}
}
visitType(te, path);
path = path.append(TypeAnnotationPosition.TypePathEntry.INNER_TYPE);
}
return null;
}

@Override
public Void visitWildcardType(
WildcardType t, List<TypeAnnotationPosition.TypePathEntry> path) {
visit(t.type, path.append(TypeAnnotationPosition.TypePathEntry.WILDCARD));
return super.visitWildcardType(t, path);
}

@Override
public Void visitArrayType(ArrayType t, List<TypeAnnotationPosition.TypePathEntry> path) {
visit(t.elemtype, path.append(TypeAnnotationPosition.TypePathEntry.ARRAY));
return super.visitArrayType(t, path);
}

@Override
public Void visitType(Type t, List<TypeAnnotationPosition.TypePathEntry> path) {
ListBuffer<Attribute.TypeCompound> attributes = attributesByPath.remove(path);
if (attributes != null) {
attributesByType.put(t, attributes.toList());
}
return null;
}
}

/** A type mapping that rewrites the type to include type annotations. */
private static class TypeAnnotationTypeMapping extends Type.StructuralTypeMapping<Void> {

private final Map<Type, List<Attribute.TypeCompound>> attributesByType;

private TypeAnnotationTypeMapping(
Map<Type, List<Attribute.TypeCompound>> attributesByType) {
this.attributesByType = attributesByType;
}

private <T extends Type> Type reannotate(T t, BiFunction<T, Void, Type> f) {
// We're relying on object identify of Type instances to record where the annotations
// need to be added, so we have to retrieve the annotations for each type before
// rewriting it, and then add them after its contained types have been rewritten.
List<Attribute.TypeCompound> attributes = attributesByType.remove(t);
Type mapped = f.apply(t, null);
if (attributes == null) {
return mapped;
}
// Runtime-visible and -invisible annotations are completed separately, so if the same
// type has annotations from both it will get annotated twice.
TypeMetadata metadata = mapped.getMetadata();
// TypeMetadata.Annotations existing =
// (TypeMetadata.Annotations) metadata.get(TypeMetadata.Entry.Kind.ANNOTATIONS);
// if (existing != null) {
// TypeMetadata.Annotations combined = new TypeMetadata.Annotations(
// existing.getAnnotations().appendList(attributes));
// return mapped.cloneWithMetadata(
// metadata.without(TypeMetadata.Entry.Kind.ANNOTATIONS).combine(combined));
// }
return mapped.annotatedType(attributes);
}

@Override
public Type visitClassType(ClassType t, Void unused) {
return reannotate(t, super::visitClassType);
}

@Override
public Type visitWildcardType(WildcardType t, Void unused) {
return reannotate(t, super::visitWildcardType);
}

@Override
public Type visitArrayType(ArrayType t, Void unused) {
return reannotate(t, super::visitArrayType);
}

@Override
public Type visitType(Type t, Void unused) {
return reannotate(t, (x, u) -> x);
}
}

/************************************************************************
* Reading Symbols
Expand Down
15 changes: 14 additions & 1 deletion test/langtools/tools/javac/processing/model/type/BasicAnnoTests.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,7 @@

/*
* @test
* @bug 8013852 8031744
* @bug 8013852 8031744 8225377
* @summary Annotations on types
* @library /tools/javac/lib
* @modules jdk.compiler/com.sun.tools.javac.api
Expand All @@ -33,13 +33,16 @@
* jdk.compiler/com.sun.tools.javac.util
* @build JavacTestingAbstractProcessor DPrinter BasicAnnoTests
* @compile/process -XDaccessInternalAPI -processor BasicAnnoTests -proc:only BasicAnnoTests.java
* @compile/process -XDaccessInternalAPI -processor BasicAnnoTests -proc:only BasicAnnoTests
*/

import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;

Expand Down Expand Up @@ -405,6 +408,12 @@ R scan(Iterable<? extends TypeMirror> iter, P p) {
int value();
}

@Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TD {
int value();
}

// Test cases

// TODO: add more cases for arrays
Expand Down Expand Up @@ -527,6 +536,10 @@ public class Inner6<T extends Object & Cloneable & @TA(17) Serializable> {}
@Test(posn=1, annoType=TA.class, expect="23")
public Set<@TA(23) ? super Object> f9;

@Test(posn=0, annoType=TA.class, expect="1")
@Test(posn=0, annoType=TD.class, expect="2")
public @TA(1) @TD(2) int f10;

// Test type use annotations on uses of type variables
@Test(posn=5, annoType = TA.class, expect = "25")
@Test(posn=5, annoType = TB.class, expect = "26")
Expand Down