8322883: [BACKOUT] 8225377: type annotations are not visible to javac plugins across compilation boundaries

Reviewed-by: mdoerr
Backport-of: ea6fc2147182f5b7168dc6f4e240c49446bf2ca3

Author: GoeLin

src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassReader.java

@@ -36,8 +36,6 @@
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.BiFunction;
-import java.util.function.Predicate;
 
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.NestingKind;
@@ -2389,320 +2387,12 @@ 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();
-            /* possible information loss if the type of the method is void then we can't add type
-             * annotations to it
-             */
-            if (!mt.restype.hasTag(TypeTag.VOID)) {
-                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