| /* |
| * Copyright (c) 2009, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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. |
| */ |
| |
| package com.sun.tools.javac.code; |
| |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.ElementKind; |
| import javax.lang.model.type.TypeKind; |
| import javax.tools.JavaFileObject; |
| |
| import com.sun.tools.javac.code.Attribute.Array; |
| import com.sun.tools.javac.code.Attribute.TypeCompound; |
| import com.sun.tools.javac.code.Symbol.ClassSymbol; |
| import com.sun.tools.javac.code.Symbol.TypeSymbol; |
| import com.sun.tools.javac.code.Type.ArrayType; |
| import com.sun.tools.javac.code.Type.CapturedType; |
| import com.sun.tools.javac.code.Type.ClassType; |
| import com.sun.tools.javac.code.Type.ErrorType; |
| import com.sun.tools.javac.code.Type.ForAll; |
| import com.sun.tools.javac.code.Type.MethodType; |
| import com.sun.tools.javac.code.Type.PackageType; |
| import com.sun.tools.javac.code.Type.TypeVar; |
| import com.sun.tools.javac.code.Type.UndetVar; |
| import com.sun.tools.javac.code.Type.Visitor; |
| import com.sun.tools.javac.code.Type.WildcardType; |
| import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry; |
| import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntryKind; |
| import com.sun.tools.javac.code.Symbol.VarSymbol; |
| import com.sun.tools.javac.code.Symbol.MethodSymbol; |
| import com.sun.tools.javac.code.TypeMetadata.Entry.Kind; |
| import com.sun.tools.javac.comp.Annotate; |
| import com.sun.tools.javac.comp.Attr; |
| import com.sun.tools.javac.comp.AttrContext; |
| import com.sun.tools.javac.comp.Env; |
| import com.sun.tools.javac.tree.JCTree; |
| import com.sun.tools.javac.tree.TreeInfo; |
| import com.sun.tools.javac.tree.JCTree.JCBlock; |
| import com.sun.tools.javac.tree.JCTree.JCClassDecl; |
| import com.sun.tools.javac.tree.JCTree.JCExpression; |
| import com.sun.tools.javac.tree.JCTree.JCLambda; |
| import com.sun.tools.javac.tree.JCTree.JCMethodDecl; |
| import com.sun.tools.javac.tree.JCTree.JCMethodInvocation; |
| import com.sun.tools.javac.tree.JCTree.JCNewClass; |
| import com.sun.tools.javac.tree.JCTree.JCTypeApply; |
| import com.sun.tools.javac.tree.JCTree.JCVariableDecl; |
| import com.sun.tools.javac.tree.TreeScanner; |
| import com.sun.tools.javac.tree.JCTree.*; |
| import com.sun.tools.javac.util.Assert; |
| import com.sun.tools.javac.util.Context; |
| import com.sun.tools.javac.util.List; |
| import com.sun.tools.javac.util.ListBuffer; |
| import com.sun.tools.javac.util.Log; |
| import com.sun.tools.javac.util.Names; |
| |
| import static com.sun.tools.javac.code.Kinds.Kind.*; |
| |
| /** |
| * Contains operations specific to processing type annotations. |
| * This class has two functions: |
| * separate declaration from type annotations and insert the type |
| * annotations to their types; |
| * and determine the TypeAnnotationPositions for all type annotations. |
| */ |
| public class TypeAnnotations { |
| protected static final Context.Key<TypeAnnotations> typeAnnosKey = new Context.Key<>(); |
| |
| public static TypeAnnotations instance(Context context) { |
| TypeAnnotations instance = context.get(typeAnnosKey); |
| if (instance == null) |
| instance = new TypeAnnotations(context); |
| return instance; |
| } |
| |
| final Log log; |
| final Names names; |
| final Symtab syms; |
| final Annotate annotate; |
| final Attr attr; |
| |
| protected TypeAnnotations(Context context) { |
| context.put(typeAnnosKey, this); |
| names = Names.instance(context); |
| log = Log.instance(context); |
| syms = Symtab.instance(context); |
| annotate = Annotate.instance(context); |
| attr = Attr.instance(context); |
| } |
| |
| /** |
| * Separate type annotations from declaration annotations and |
| * determine the correct positions for type annotations. |
| * This version only visits types in signatures and should be |
| * called from MemberEnter. |
| */ |
| public void organizeTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) { |
| annotate.afterTypes(() -> { |
| JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile); |
| try { |
| new TypeAnnotationPositions(true).scan(tree); |
| } finally { |
| log.useSource(oldSource); |
| } |
| }); |
| } |
| |
| public void validateTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) { |
| annotate.validate(() -> { //validate annotations |
| JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile); |
| try { |
| attr.validateTypeAnnotations(tree, true); |
| } finally { |
| log.useSource(oldSource); |
| } |
| }); |
| } |
| |
| /** |
| * This version only visits types in bodies, that is, field initializers, |
| * top-level blocks, and method bodies, and should be called from Attr. |
| */ |
| public void organizeTypeAnnotationsBodies(JCClassDecl tree) { |
| new TypeAnnotationPositions(false).scan(tree); |
| } |
| |
| public enum AnnotationType { DECLARATION, TYPE, NONE, BOTH } |
| |
| public List<Attribute> annotationTargets(TypeSymbol tsym) { |
| Attribute.Compound atTarget = tsym.getAnnotationTypeMetadata().getTarget(); |
| if (atTarget == null) { |
| return null; |
| } |
| |
| Attribute atValue = atTarget.member(names.value); |
| if (!(atValue instanceof Attribute.Array)) { |
| return null; |
| } |
| |
| List<Attribute> targets = ((Array)atValue).getValue(); |
| if (targets.stream().anyMatch(a -> !(a instanceof Attribute.Enum))) { |
| return null; |
| } |
| |
| return targets; |
| } |
| |
| /** |
| * Determine whether an annotation is a declaration annotation, |
| * a type annotation, or both. |
| */ |
| public AnnotationType annotationTargetType(Attribute.Compound a, Symbol s) { |
| List<Attribute> targets = annotationTargets(a.type.tsym); |
| return (targets == null) ? |
| AnnotationType.DECLARATION : |
| targets.stream() |
| .map(attr -> targetToAnnotationType(attr, s)) |
| .reduce(AnnotationType.NONE, this::combineAnnotationType); |
| } |
| |
| private AnnotationType combineAnnotationType(AnnotationType at1, AnnotationType at2) { |
| if (at1 == AnnotationType.NONE) { |
| return at2; |
| } else if (at2 == AnnotationType.NONE) { |
| return at1; |
| } else if (at1 != at2) { |
| return AnnotationType.BOTH; |
| } else { |
| return at1; |
| } |
| } |
| |
| private AnnotationType targetToAnnotationType(Attribute a, Symbol s) { |
| Attribute.Enum e = (Attribute.Enum)a; |
| if (e.value.name == names.TYPE) { |
| if (s.kind == TYP) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.FIELD) { |
| if (s.kind == VAR && |
| s.owner.kind != MTH) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.METHOD) { |
| if (s.kind == MTH && |
| !s.isConstructor()) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.PARAMETER) { |
| if (s.kind == VAR && |
| s.owner.kind == MTH && |
| (s.flags() & Flags.PARAMETER) != 0) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.CONSTRUCTOR) { |
| if (s.kind == MTH && |
| s.isConstructor()) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.LOCAL_VARIABLE) { |
| if (s.kind == VAR && |
| s.owner.kind == MTH && |
| (s.flags() & Flags.PARAMETER) == 0) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.ANNOTATION_TYPE) { |
| if (s.kind == TYP && |
| (s.flags() & Flags.ANNOTATION) != 0) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.PACKAGE) { |
| if (s.kind == PCK) |
| return AnnotationType.DECLARATION; |
| } else if (e.value.name == names.TYPE_USE) { |
| if (s.kind == TYP || |
| s.kind == VAR || |
| (s.kind == MTH && !s.isConstructor() && |
| !s.type.getReturnType().hasTag(TypeTag.VOID)) || |
| (s.kind == MTH && s.isConstructor())) |
| return AnnotationType.TYPE; |
| } else if (e.value.name == names.TYPE_PARAMETER) { |
| /* Irrelevant in this case */ |
| // TYPE_PARAMETER doesn't aid in distinguishing between |
| // Type annotations and declaration annotations on an |
| // Element |
| } else { |
| Assert.error("annotationTargetType(): unrecognized Attribute name " + e.value.name + |
| " (" + e.value.name.getClass() + ")"); |
| return AnnotationType.DECLARATION; |
| } |
| return AnnotationType.NONE; |
| } |
| |
| private class TypeAnnotationPositions extends TreeScanner { |
| |
| private final boolean sigOnly; |
| |
| TypeAnnotationPositions(boolean sigOnly) { |
| this.sigOnly = sigOnly; |
| } |
| |
| /* |
| * When traversing the AST we keep the "frames" of visited |
| * trees in order to determine the position of annotations. |
| */ |
| private List<JCTree> frames = List.nil(); |
| |
| protected void push(JCTree t) { |
| frames = frames.prepend(t); |
| } |
| protected JCTree pop() { |
| JCTree t = frames.head; |
| frames = frames.tail; |
| return t; |
| } |
| // could this be frames.elems.tail.head? |
| private JCTree peek2() { |
| return frames.tail.head; |
| } |
| |
| @Override |
| public void scan(JCTree tree) { |
| push(tree); |
| try { |
| super.scan(tree); |
| } finally { |
| pop(); |
| } |
| } |
| |
| /** |
| * Separates type annotations from declaration annotations. |
| * This step is needed because in certain locations (where declaration |
| * and type annotations can be mixed, e.g. the type of a field) |
| * we never build an JCAnnotatedType. This step finds these |
| * annotations and marks them as if they were part of the type. |
| */ |
| private void separateAnnotationsKinds(JCTree typetree, Type type, |
| Symbol sym, TypeAnnotationPosition pos) |
| { |
| List<Attribute.Compound> allAnnotations = sym.getRawAttributes(); |
| ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<>(); |
| ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<>(); |
| ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<>(); |
| |
| for (Attribute.Compound a : allAnnotations) { |
| switch (annotationTargetType(a, sym)) { |
| case DECLARATION: |
| declAnnos.append(a); |
| break; |
| case BOTH: { |
| declAnnos.append(a); |
| Attribute.TypeCompound ta = toTypeCompound(a, pos); |
| typeAnnos.append(ta); |
| break; |
| } |
| case TYPE: { |
| Attribute.TypeCompound ta = toTypeCompound(a, pos); |
| typeAnnos.append(ta); |
| // Also keep track which annotations are only type annotations |
| onlyTypeAnnos.append(ta); |
| break; |
| } |
| } |
| } |
| |
| // If we have no type annotations we are done for this Symbol |
| if (typeAnnos.isEmpty()) { |
| return; |
| } |
| |
| // Reset decl annotations to the set {all - type only} |
| sym.resetAnnotations(); |
| sym.setDeclarationAttributes(declAnnos.toList()); |
| |
| List<Attribute.TypeCompound> typeAnnotations = typeAnnos.toList(); |
| |
| if (type == null) { |
| // When type is null, put the type annotations to the symbol. |
| // This is used for constructor return annotations, for which |
| // we use the type of the enclosing class. |
| type = sym.getEnclosingElement().asType(); |
| |
| // Declaration annotations are always allowed on constructor returns. |
| // Therefore, use typeAnnotations instead of onlyTypeAnnos. |
| typeWithAnnotations(typetree, type, typeAnnotations, typeAnnotations, pos); |
| // Note that we don't use the result, the call to |
| // typeWithAnnotations side-effects the type annotation positions. |
| // This is important for constructors of nested classes. |
| sym.appendUniqueTypeAttributes(typeAnnotations); |
| return; |
| } |
| |
| // type is non-null, add type annotations from declaration context to the type |
| type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList(), pos); |
| |
| if (sym.getKind() == ElementKind.METHOD) { |
| sym.type.asMethodType().restype = type; |
| } else if (sym.getKind() == ElementKind.PARAMETER && currentLambda == null) { |
| sym.type = type; |
| if (sym.getQualifiedName().equals(names._this)) { |
| sym.owner.type.asMethodType().recvtype = type; |
| // note that the typeAnnotations will also be added to the owner below. |
| } else { |
| MethodType methType = sym.owner.type.asMethodType(); |
| List<VarSymbol> params = ((MethodSymbol)sym.owner).params; |
| List<Type> oldArgs = methType.argtypes; |
| ListBuffer<Type> newArgs = new ListBuffer<>(); |
| while (params.nonEmpty()) { |
| if (params.head == sym) { |
| newArgs.add(type); |
| } else { |
| newArgs.add(oldArgs.head); |
| } |
| oldArgs = oldArgs.tail; |
| params = params.tail; |
| } |
| methType.argtypes = newArgs.toList(); |
| } |
| } else { |
| sym.type = type; |
| } |
| |
| sym.appendUniqueTypeAttributes(typeAnnotations); |
| |
| if (sym.getKind() == ElementKind.PARAMETER || |
| sym.getKind() == ElementKind.LOCAL_VARIABLE || |
| sym.getKind() == ElementKind.RESOURCE_VARIABLE || |
| sym.getKind() == ElementKind.EXCEPTION_PARAMETER) { |
| // Make sure all type annotations from the symbol are also |
| // on the owner. If the owner is an initializer block, propagate |
| // to the type. |
| final long ownerFlags = sym.owner.flags(); |
| if ((ownerFlags & Flags.BLOCK) != 0) { |
| // Store init and clinit type annotations with the ClassSymbol |
| // to allow output in Gen.normalizeDefs. |
| ClassSymbol cs = (ClassSymbol) sym.owner.owner; |
| if ((ownerFlags & Flags.STATIC) != 0) { |
| cs.appendClassInitTypeAttributes(typeAnnotations); |
| } else { |
| cs.appendInitTypeAttributes(typeAnnotations); |
| } |
| } else { |
| sym.owner.appendUniqueTypeAttributes(sym.getRawTypeAttributes()); |
| } |
| } |
| } |
| |
| // This method has a similar purpose as |
| // {@link com.sun.tools.javac.parser.JavacParser.insertAnnotationsToMostInner(JCExpression, List<JCTypeAnnotation>, boolean)} |
| // We found a type annotation in a declaration annotation position, |
| // for example, on the return type. |
| // Such an annotation is _not_ part of an JCAnnotatedType tree and we therefore |
| // need to set its position explicitly. |
| // The method returns a copy of type that contains these annotations. |
| // |
| // As a side effect the method sets the type annotation position of "annotations". |
| // Note that it is assumed that all annotations share the same position. |
| private Type typeWithAnnotations(final JCTree typetree, final Type type, |
| final List<Attribute.TypeCompound> annotations, |
| final List<Attribute.TypeCompound> onlyTypeAnnotations, |
| final TypeAnnotationPosition pos) |
| { |
| if (annotations.isEmpty()) { |
| return type; |
| } |
| |
| if (type.hasTag(TypeTag.ARRAY)) |
| return rewriteArrayType((ArrayType)type, annotations, pos); |
| |
| if (type.hasTag(TypeTag.TYPEVAR)) { |
| return type.annotatedType(onlyTypeAnnotations); |
| } else if (type.getKind() == TypeKind.UNION) { |
| // There is a TypeKind, but no TypeTag. |
| JCTypeUnion tutree = (JCTypeUnion)typetree; |
| JCExpression fst = tutree.alternatives.get(0); |
| Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations, pos); |
| fst.type = res; |
| // TODO: do we want to set res as first element in uct.alternatives? |
| // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type; |
| // Return the un-annotated union-type. |
| return type; |
| } else { |
| Type enclTy = type; |
| Element enclEl = type.asElement(); |
| JCTree enclTr = typetree; |
| |
| while (enclEl != null && |
| enclEl.getKind() != ElementKind.PACKAGE && |
| enclTy != null && |
| enclTy.getKind() != TypeKind.NONE && |
| enclTy.getKind() != TypeKind.ERROR && |
| (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT || |
| enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE || |
| enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) { |
| // Iterate also over the type tree, not just the type: the type is already |
| // completely resolved and we cannot distinguish where the annotation |
| // belongs for a nested type. |
| if (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT) { |
| // only change encl in this case. |
| enclTy = enclTy.getEnclosingType(); |
| enclEl = enclEl.getEnclosingElement(); |
| enclTr = ((JCFieldAccess)enclTr).getExpression(); |
| } else if (enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE) { |
| enclTr = ((JCTypeApply)enclTr).getType(); |
| } else { |
| // only other option because of while condition |
| enclTr = ((JCAnnotatedType)enclTr).getUnderlyingType(); |
| } |
| } |
| |
| /** We are trying to annotate some enclosing type, |
| * but nothing more exists. |
| */ |
| if (enclTy != null && |
| enclTy.hasTag(TypeTag.NONE)) { |
| switch (onlyTypeAnnotations.size()) { |
| case 0: |
| // Don't issue an error if all type annotations are |
| // also declaration annotations. |
| // If the annotations are also declaration annotations, they are |
| // illegal as type annotations but might be legal as declaration annotations. |
| // The normal declaration annotation checks make sure that the use is valid. |
| break; |
| case 1: |
| log.error(typetree.pos(), "cant.type.annotate.scoping.1", |
| onlyTypeAnnotations); |
| break; |
| default: |
| log.error(typetree.pos(), "cant.type.annotate.scoping", |
| onlyTypeAnnotations); |
| } |
| return type; |
| } |
| |
| // At this point we have visited the part of the nested |
| // type that is written in the source code. |
| // Now count from here to the actual top-level class to determine |
| // the correct nesting. |
| |
| // The genericLocation for the annotation. |
| ListBuffer<TypePathEntry> depth = new ListBuffer<>(); |
| |
| Type topTy = enclTy; |
| while (enclEl != null && |
| enclEl.getKind() != ElementKind.PACKAGE && |
| topTy != null && |
| topTy.getKind() != TypeKind.NONE && |
| topTy.getKind() != TypeKind.ERROR) { |
| topTy = topTy.getEnclosingType(); |
| enclEl = enclEl.getEnclosingElement(); |
| |
| if (topTy != null && topTy.getKind() != TypeKind.NONE) { |
| // Only count enclosing types. |
| depth = depth.append(TypePathEntry.INNER_TYPE); |
| } |
| } |
| |
| if (depth.nonEmpty()) { |
| // Only need to change the annotation positions |
| // if they are on an enclosed type. |
| // All annotations share the same position; modify the first one. |
| Attribute.TypeCompound a = annotations.get(0); |
| TypeAnnotationPosition p = a.position; |
| p.location = p.location.appendList(depth.toList()); |
| } |
| |
| Type ret = typeWithAnnotations(type, enclTy, annotations); |
| typetree.type = ret; |
| return ret; |
| } |
| } |
| |
| /** |
| * Create a copy of the {@code Type type} with the help of the Tree for a type |
| * {@code JCTree typetree} inserting all type annotations in {@code annotations} to the |
| * innermost array component type. |
| * |
| * SIDE EFFECT: Update position for the annotations to be {@code pos}. |
| */ |
| private Type rewriteArrayType(ArrayType type, List<TypeCompound> annotations, TypeAnnotationPosition pos) { |
| ArrayType tomodify = new ArrayType(type); |
| ArrayType res = tomodify; |
| |
| List<TypePathEntry> loc = List.nil(); |
| |
| // peel one and update loc |
| Type tmpType = type.elemtype; |
| loc = loc.prepend(TypePathEntry.ARRAY); |
| |
| while (tmpType.hasTag(TypeTag.ARRAY)) { |
| ArrayType arr = (ArrayType)tmpType; |
| |
| // Update last type with new element type |
| ArrayType tmp = new ArrayType(arr); |
| tomodify.elemtype = tmp; |
| tomodify = tmp; |
| |
| tmpType = arr.elemtype; |
| loc = loc.prepend(TypePathEntry.ARRAY); |
| } |
| |
| // Fix innermost element type |
| Type elemType; |
| if (tmpType.getMetadata() != null) { |
| List<TypeCompound> tcs; |
| if (tmpType.getAnnotationMirrors().isEmpty()) { |
| tcs = annotations; |
| } else { |
| // Special case, lets prepend |
| tcs = annotations.appendList(tmpType.getAnnotationMirrors()); |
| } |
| elemType = tmpType.cloneWithMetadata(tmpType |
| .getMetadata() |
| .without(Kind.ANNOTATIONS) |
| .combine(new TypeMetadata.Annotations(tcs))); |
| } else { |
| elemType = tmpType.cloneWithMetadata(new TypeMetadata(new TypeMetadata.Annotations(annotations))); |
| } |
| tomodify.elemtype = elemType; |
| |
| // Update positions |
| for (TypeCompound tc : annotations) { |
| if (tc.position == null) |
| tc.position = pos; |
| tc.position.location = loc; |
| } |
| |
| return res; |
| } |
| |
| /** Return a copy of the first type that only differs by |
| * inserting the annotations to the left-most/inner-most type |
| * or the type given by stopAt. |
| * |
| * We need the stopAt parameter to know where on a type to |
| * put the annotations. |
| * If we have nested classes Outer > Middle > Inner, and we |
| * have the source type "@A Middle.Inner", we will invoke |
| * this method with type = Outer.Middle.Inner, |
| * stopAt = Middle.Inner, and annotations = @A. |
| * |
| * @param type The type to copy. |
| * @param stopAt The type to stop at. |
| * @param annotations The annotations to insert. |
| * @return A copy of type that contains the annotations. |
| */ |
| private Type typeWithAnnotations(final Type type, |
| final Type stopAt, |
| final List<Attribute.TypeCompound> annotations) { |
| Visitor<Type, List<TypeCompound>> visitor = |
| new Type.Visitor<Type, List<Attribute.TypeCompound>>() { |
| @Override |
| public Type visitClassType(ClassType t, List<TypeCompound> s) { |
| // assert that t.constValue() == null? |
| if (t == stopAt || |
| t.getEnclosingType() == Type.noType) { |
| return t.annotatedType(s); |
| } else { |
| ClassType ret = new ClassType(t.getEnclosingType().accept(this, s), |
| t.typarams_field, t.tsym, |
| t.getMetadata()); |
| ret.all_interfaces_field = t.all_interfaces_field; |
| ret.allparams_field = t.allparams_field; |
| ret.interfaces_field = t.interfaces_field; |
| ret.rank_field = t.rank_field; |
| ret.supertype_field = t.supertype_field; |
| return ret; |
| } |
| } |
| |
| @Override |
| public Type visitWildcardType(WildcardType t, List<TypeCompound> s) { |
| return t.annotatedType(s); |
| } |
| |
| @Override |
| public Type visitArrayType(ArrayType t, List<TypeCompound> s) { |
| ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym, |
| t.getMetadata()); |
| return ret; |
| } |
| |
| @Override |
| public Type visitMethodType(MethodType t, List<TypeCompound> s) { |
| // Impossible? |
| return t; |
| } |
| |
| @Override |
| public Type visitPackageType(PackageType t, List<TypeCompound> s) { |
| // Impossible? |
| return t; |
| } |
| |
| @Override |
| public Type visitTypeVar(TypeVar t, List<TypeCompound> s) { |
| return t.annotatedType(s); |
| } |
| |
| @Override |
| public Type visitCapturedType(CapturedType t, List<TypeCompound> s) { |
| return t.annotatedType(s); |
| } |
| |
| @Override |
| public Type visitForAll(ForAll t, List<TypeCompound> s) { |
| // Impossible? |
| return t; |
| } |
| |
| @Override |
| public Type visitUndetVar(UndetVar t, List<TypeCompound> s) { |
| // Impossible? |
| return t; |
| } |
| |
| @Override |
| public Type visitErrorType(ErrorType t, List<TypeCompound> s) { |
| return t.annotatedType(s); |
| } |
| |
| @Override |
| public Type visitType(Type t, List<TypeCompound> s) { |
| return t.annotatedType(s); |
| } |
| }; |
| |
| return type.accept(visitor, annotations); |
| } |
| |
| private Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) { |
| // It is safe to alias the position. |
| return new Attribute.TypeCompound(a, p); |
| } |
| |
| |
| /* This is the beginning of the second part of organizing |
| * type annotations: determine the type annotation positions. |
| */ |
| private TypeAnnotationPosition |
| resolveFrame(JCTree tree, |
| JCTree frame, |
| List<JCTree> path, |
| JCLambda currentLambda, |
| int outer_type_index, |
| ListBuffer<TypePathEntry> location) |
| { |
| |
| // Note that p.offset is set in |
| // com.sun.tools.javac.jvm.Gen.setTypeAnnotationPositions(int) |
| |
| switch (frame.getKind()) { |
| case TYPE_CAST: |
| return TypeAnnotationPosition.typeCast(location.toList(), |
| currentLambda, |
| outer_type_index, |
| frame.pos); |
| |
| case INSTANCE_OF: |
| return TypeAnnotationPosition.instanceOf(location.toList(), |
| currentLambda, |
| frame.pos); |
| |
| case NEW_CLASS: |
| final JCNewClass frameNewClass = (JCNewClass) frame; |
| if (frameNewClass.def != null) { |
| // Special handling for anonymous class instantiations |
| final JCClassDecl frameClassDecl = frameNewClass.def; |
| if (frameClassDecl.implementing.contains(tree)) { |
| final int type_index = |
| frameClassDecl.implementing.indexOf(tree); |
| return TypeAnnotationPosition |
| .classExtends(location.toList(), currentLambda, |
| type_index, frame.pos); |
| } else { |
| //for encl.new @TA Clazz(), tree may be different from frameClassDecl.extending |
| return TypeAnnotationPosition |
| .classExtends(location.toList(), currentLambda, |
| frame.pos); |
| } |
| } else if (frameNewClass.typeargs.contains(tree)) { |
| final int type_index = |
| frameNewClass.typeargs.indexOf(tree); |
| return TypeAnnotationPosition |
| .constructorInvocationTypeArg(location.toList(), |
| currentLambda, |
| type_index, |
| frame.pos); |
| } else { |
| return TypeAnnotationPosition |
| .newObj(location.toList(), currentLambda, |
| frame.pos); |
| } |
| |
| case NEW_ARRAY: |
| return TypeAnnotationPosition |
| .newObj(location.toList(), currentLambda, frame.pos); |
| |
| case ANNOTATION_TYPE: |
| case CLASS: |
| case ENUM: |
| case INTERFACE: |
| if (((JCClassDecl)frame).extending == tree) { |
| return TypeAnnotationPosition |
| .classExtends(location.toList(), currentLambda, |
| frame.pos); |
| } else if (((JCClassDecl)frame).implementing.contains(tree)) { |
| final int type_index = |
| ((JCClassDecl)frame).implementing.indexOf(tree); |
| return TypeAnnotationPosition |
| .classExtends(location.toList(), currentLambda, |
| type_index, frame.pos); |
| } else if (((JCClassDecl)frame).typarams.contains(tree)) { |
| final int parameter_index = |
| ((JCClassDecl)frame).typarams.indexOf(tree); |
| return TypeAnnotationPosition |
| .typeParameter(location.toList(), currentLambda, |
| parameter_index, frame.pos); |
| } else { |
| throw new AssertionError("Could not determine position of tree " + |
| tree + " within frame " + frame); |
| } |
| |
| case METHOD: { |
| final JCMethodDecl frameMethod = (JCMethodDecl) frame; |
| if (frameMethod.thrown.contains(tree)) { |
| final int type_index = frameMethod.thrown.indexOf(tree); |
| return TypeAnnotationPosition |
| .methodThrows(location.toList(), currentLambda, |
| type_index, frame.pos); |
| } else if (frameMethod.restype == tree) { |
| return TypeAnnotationPosition |
| .methodReturn(location.toList(), currentLambda, |
| frame.pos); |
| } else if (frameMethod.typarams.contains(tree)) { |
| final int parameter_index = |
| frameMethod.typarams.indexOf(tree); |
| return TypeAnnotationPosition |
| .methodTypeParameter(location.toList(), |
| currentLambda, |
| parameter_index, frame.pos); |
| } else { |
| throw new AssertionError("Could not determine position of tree " + tree + |
| " within frame " + frame); |
| } |
| } |
| |
| case PARAMETERIZED_TYPE: { |
| List<JCTree> newPath = path.tail; |
| |
| if (((JCTypeApply)frame).clazz == tree) { |
| // generic: RAW; noop |
| } else if (((JCTypeApply)frame).arguments.contains(tree)) { |
| JCTypeApply taframe = (JCTypeApply) frame; |
| int arg = taframe.arguments.indexOf(tree); |
| location = location.prepend( |
| new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT, |
| arg)); |
| |
| Type typeToUse; |
| if (newPath.tail != null && |
| newPath.tail.head.hasTag(Tag.NEWCLASS)) { |
| // If we are within an anonymous class |
| // instantiation, use its type, because it |
| // contains a correctly nested type. |
| typeToUse = newPath.tail.head.type; |
| } else { |
| typeToUse = taframe.type; |
| } |
| |
| location = locateNestedTypes(typeToUse, location); |
| } else { |
| throw new AssertionError("Could not determine type argument position of tree " + tree + |
| " within frame " + frame); |
| } |
| |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, location); |
| } |
| |
| case MEMBER_REFERENCE: { |
| JCMemberReference mrframe = (JCMemberReference) frame; |
| |
| if (mrframe.expr == tree) { |
| switch (mrframe.mode) { |
| case INVOKE: |
| return TypeAnnotationPosition |
| .methodRef(location.toList(), currentLambda, |
| frame.pos); |
| case NEW: |
| return TypeAnnotationPosition |
| .constructorRef(location.toList(), |
| currentLambda, |
| frame.pos); |
| default: |
| throw new AssertionError("Unknown method reference mode " + mrframe.mode + |
| " for tree " + tree + " within frame " + frame); |
| } |
| } else if (mrframe.typeargs != null && |
| mrframe.typeargs.contains(tree)) { |
| final int type_index = mrframe.typeargs.indexOf(tree); |
| switch (mrframe.mode) { |
| case INVOKE: |
| return TypeAnnotationPosition |
| .methodRefTypeArg(location.toList(), |
| currentLambda, |
| type_index, frame.pos); |
| case NEW: |
| return TypeAnnotationPosition |
| .constructorRefTypeArg(location.toList(), |
| currentLambda, |
| type_index, frame.pos); |
| default: |
| throw new AssertionError("Unknown method reference mode " + mrframe.mode + |
| " for tree " + tree + " within frame " + frame); |
| } |
| } else { |
| throw new AssertionError("Could not determine type argument position of tree " + tree + |
| " within frame " + frame); |
| } |
| } |
| |
| case ARRAY_TYPE: { |
| location = location.prepend(TypePathEntry.ARRAY); |
| List<JCTree> newPath = path.tail; |
| while (true) { |
| JCTree npHead = newPath.tail.head; |
| if (npHead.hasTag(JCTree.Tag.TYPEARRAY)) { |
| newPath = newPath.tail; |
| location = location.prepend(TypePathEntry.ARRAY); |
| } else if (npHead.hasTag(JCTree.Tag.ANNOTATED_TYPE)) { |
| newPath = newPath.tail; |
| } else { |
| break; |
| } |
| } |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, location); |
| } |
| |
| case TYPE_PARAMETER: |
| if (path.tail.tail.head.hasTag(JCTree.Tag.CLASSDEF)) { |
| final JCClassDecl clazz = |
| (JCClassDecl)path.tail.tail.head; |
| final int parameter_index = |
| clazz.typarams.indexOf(path.tail.head); |
| final int bound_index = |
| ((JCTypeParameter)frame).bounds.get(0) |
| .type.isInterface() ? |
| ((JCTypeParameter)frame).bounds.indexOf(tree) + 1: |
| ((JCTypeParameter)frame).bounds.indexOf(tree); |
| return TypeAnnotationPosition |
| .typeParameterBound(location.toList(), |
| currentLambda, |
| parameter_index, bound_index, |
| frame.pos); |
| } else if (path.tail.tail.head.hasTag(JCTree.Tag.METHODDEF)) { |
| final JCMethodDecl method = |
| (JCMethodDecl)path.tail.tail.head; |
| final int parameter_index = |
| method.typarams.indexOf(path.tail.head); |
| final int bound_index = |
| ((JCTypeParameter)frame).bounds.get(0) |
| .type.isInterface() ? |
| ((JCTypeParameter)frame).bounds.indexOf(tree) + 1: |
| ((JCTypeParameter)frame).bounds.indexOf(tree); |
| return TypeAnnotationPosition |
| .methodTypeParameterBound(location.toList(), |
| currentLambda, |
| parameter_index, |
| bound_index, |
| frame.pos); |
| } else { |
| throw new AssertionError("Could not determine position of tree " + tree + |
| " within frame " + frame); |
| } |
| |
| case VARIABLE: |
| VarSymbol v = ((JCVariableDecl)frame).sym; |
| if (v.getKind() != ElementKind.FIELD) { |
| v.owner.appendUniqueTypeAttributes(v.getRawTypeAttributes()); |
| } |
| switch (v.getKind()) { |
| case LOCAL_VARIABLE: |
| return TypeAnnotationPosition |
| .localVariable(location.toList(), currentLambda, |
| frame.pos); |
| case FIELD: |
| return TypeAnnotationPosition.field(location.toList(), |
| currentLambda, |
| frame.pos); |
| case PARAMETER: |
| if (v.getQualifiedName().equals(names._this)) { |
| return TypeAnnotationPosition |
| .methodReceiver(location.toList(), |
| currentLambda, |
| frame.pos); |
| } else { |
| final int parameter_index = |
| methodParamIndex(path, frame); |
| return TypeAnnotationPosition |
| .methodParameter(location.toList(), |
| currentLambda, |
| parameter_index, |
| frame.pos); |
| } |
| case EXCEPTION_PARAMETER: |
| return TypeAnnotationPosition |
| .exceptionParameter(location.toList(), |
| currentLambda, |
| frame.pos); |
| case RESOURCE_VARIABLE: |
| return TypeAnnotationPosition |
| .resourceVariable(location.toList(), |
| currentLambda, |
| frame.pos); |
| default: |
| throw new AssertionError("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind()); |
| } |
| |
| case ANNOTATED_TYPE: { |
| if (frame == tree) { |
| // This is only true for the first annotated type we see. |
| // For any other annotated types along the path, we do |
| // not care about inner types. |
| JCAnnotatedType atypetree = (JCAnnotatedType) frame; |
| final Type utype = atypetree.underlyingType.type; |
| Assert.checkNonNull(utype); |
| Symbol tsym = utype.tsym; |
| if (tsym.getKind().equals(ElementKind.TYPE_PARAMETER) || |
| utype.getKind().equals(TypeKind.WILDCARD) || |
| utype.getKind().equals(TypeKind.ARRAY)) { |
| // Type parameters, wildcards, and arrays have the declaring |
| // class/method as enclosing elements. |
| // There is actually nothing to do for them. |
| } else { |
| location = locateNestedTypes(utype, location); |
| } |
| } |
| List<JCTree> newPath = path.tail; |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, location); |
| } |
| |
| case UNION_TYPE: { |
| List<JCTree> newPath = path.tail; |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, location); |
| } |
| |
| case INTERSECTION_TYPE: { |
| JCTypeIntersection isect = (JCTypeIntersection)frame; |
| final List<JCTree> newPath = path.tail; |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| isect.bounds.indexOf(tree), location); |
| } |
| |
| case METHOD_INVOCATION: { |
| JCMethodInvocation invocation = (JCMethodInvocation)frame; |
| if (!invocation.typeargs.contains(tree)) { |
| throw new AssertionError("{" + tree + "} is not an argument in the invocation: " + invocation); |
| } |
| MethodSymbol exsym = (MethodSymbol) TreeInfo.symbol(invocation.getMethodSelect()); |
| final int type_index = invocation.typeargs.indexOf(tree); |
| if (exsym == null) { |
| throw new AssertionError("could not determine symbol for {" + invocation + "}"); |
| } else if (exsym.isConstructor()) { |
| return TypeAnnotationPosition |
| .constructorInvocationTypeArg(location.toList(), |
| currentLambda, |
| type_index, |
| invocation.pos); |
| } else { |
| return TypeAnnotationPosition |
| .methodInvocationTypeArg(location.toList(), |
| currentLambda, |
| type_index, |
| invocation.pos); |
| } |
| } |
| |
| case EXTENDS_WILDCARD: |
| case SUPER_WILDCARD: { |
| // Annotations in wildcard bounds |
| final List<JCTree> newPath = path.tail; |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, |
| location.prepend(TypePathEntry.WILDCARD)); |
| } |
| |
| case MEMBER_SELECT: { |
| final List<JCTree> newPath = path.tail; |
| return resolveFrame(newPath.head, newPath.tail.head, |
| newPath, currentLambda, |
| outer_type_index, location); |
| } |
| |
| default: |
| throw new AssertionError("Unresolved frame: " + frame + |
| " of kind: " + frame.getKind() + |
| "\n Looking for tree: " + tree); |
| } |
| } |
| |
| private ListBuffer<TypePathEntry> |
| locateNestedTypes(Type type, |
| ListBuffer<TypePathEntry> depth) { |
| Type encl = type.getEnclosingType(); |
| while (encl != null && |
| encl.getKind() != TypeKind.NONE && |
| encl.getKind() != TypeKind.ERROR) { |
| depth = depth.prepend(TypePathEntry.INNER_TYPE); |
| encl = encl.getEnclosingType(); |
| } |
| return depth; |
| } |
| |
| private int methodParamIndex(List<JCTree> path, JCTree param) { |
| List<JCTree> curr = path; |
| while (curr.head.getTag() != Tag.METHODDEF && |
| curr.head.getTag() != Tag.LAMBDA) { |
| curr = curr.tail; |
| } |
| if (curr.head.getTag() == Tag.METHODDEF) { |
| JCMethodDecl method = (JCMethodDecl)curr.head; |
| return method.params.indexOf(param); |
| } else if (curr.head.getTag() == Tag.LAMBDA) { |
| JCLambda lambda = (JCLambda)curr.head; |
| return lambda.params.indexOf(param); |
| } else { |
| Assert.error("methodParamIndex expected to find method or lambda for param: " + param); |
| return -1; |
| } |
| } |
| |
| // Each class (including enclosed inner classes) is visited separately. |
| // This flag is used to prevent from visiting inner classes. |
| private boolean isInClass = false; |
| |
| @Override |
| public void visitClassDef(JCClassDecl tree) { |
| if (isInClass) |
| return; |
| isInClass = true; |
| |
| if (sigOnly) { |
| scan(tree.mods); |
| scan(tree.typarams); |
| scan(tree.extending); |
| scan(tree.implementing); |
| } |
| scan(tree.defs); |
| } |
| |
| /** |
| * Resolve declaration vs. type annotations in methods and |
| * then determine the positions. |
| */ |
| @Override |
| public void visitMethodDef(final JCMethodDecl tree) { |
| if (tree.sym == null) { |
| Assert.error("Visiting tree node before memberEnter"); |
| } |
| if (sigOnly) { |
| if (!tree.mods.annotations.isEmpty()) { |
| if (tree.sym.isConstructor()) { |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.methodReturn(tree.pos); |
| // Use null to mark that the annotations go |
| // with the symbol. |
| separateAnnotationsKinds(tree, null, tree.sym, pos); |
| } else { |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.methodReturn(tree.restype.pos); |
| separateAnnotationsKinds(tree.restype, |
| tree.sym.type.getReturnType(), |
| tree.sym, pos); |
| } |
| } |
| if (tree.recvparam != null && tree.recvparam.sym != null && |
| !tree.recvparam.mods.annotations.isEmpty()) { |
| // Nothing to do for separateAnnotationsKinds if |
| // there are no annotations of either kind. |
| // TODO: make sure there are no declaration annotations. |
| final TypeAnnotationPosition pos = TypeAnnotationPosition.methodReceiver(tree.recvparam.vartype.pos); |
| push(tree.recvparam); |
| try { |
| separateAnnotationsKinds(tree.recvparam.vartype, tree.recvparam.sym.type, tree.recvparam.sym, pos); |
| } finally { |
| pop(); |
| } |
| } |
| int i = 0; |
| for (JCVariableDecl param : tree.params) { |
| if (!param.mods.annotations.isEmpty()) { |
| // Nothing to do for separateAnnotationsKinds if |
| // there are no annotations of either kind. |
| final TypeAnnotationPosition pos = TypeAnnotationPosition.methodParameter(i, param.vartype.pos); |
| push(param); |
| try { |
| separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos); |
| } finally { |
| pop(); |
| } |
| } |
| ++i; |
| } |
| } |
| |
| if (sigOnly) { |
| scan(tree.mods); |
| scan(tree.restype); |
| scan(tree.typarams); |
| scan(tree.recvparam); |
| scan(tree.params); |
| scan(tree.thrown); |
| } else { |
| scan(tree.defaultValue); |
| scan(tree.body); |
| } |
| } |
| |
| /* Store a reference to the current lambda expression, to |
| * be used by all type annotations within this expression. |
| */ |
| private JCLambda currentLambda = null; |
| |
| public void visitLambda(JCLambda tree) { |
| JCLambda prevLambda = currentLambda; |
| try { |
| currentLambda = tree; |
| |
| int i = 0; |
| for (JCVariableDecl param : tree.params) { |
| if (!param.mods.annotations.isEmpty()) { |
| // Nothing to do for separateAnnotationsKinds if |
| // there are no annotations of either kind. |
| final TypeAnnotationPosition pos = TypeAnnotationPosition |
| .methodParameter(tree, i, param.vartype.pos); |
| push(param); |
| try { |
| separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos); |
| } finally { |
| pop(); |
| } |
| } |
| ++i; |
| } |
| |
| scan(tree.body); |
| scan(tree.params); |
| } finally { |
| currentLambda = prevLambda; |
| } |
| } |
| |
| /** |
| * Resolve declaration vs. type annotations in variable declarations and |
| * then determine the positions. |
| */ |
| @Override |
| public void visitVarDef(final JCVariableDecl tree) { |
| if (tree.mods.annotations.isEmpty()) { |
| // Nothing to do for separateAnnotationsKinds if |
| // there are no annotations of either kind. |
| } else if (tree.sym == null) { |
| Assert.error("Visiting tree node before memberEnter"); |
| } else if (tree.sym.getKind() == ElementKind.PARAMETER) { |
| // Parameters are handled in visitMethodDef or visitLambda. |
| } else if (tree.sym.getKind() == ElementKind.FIELD) { |
| if (sigOnly) { |
| TypeAnnotationPosition pos = |
| TypeAnnotationPosition.field(tree.pos); |
| separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos); |
| } |
| } else if (tree.sym.getKind() == ElementKind.LOCAL_VARIABLE) { |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.localVariable(currentLambda, |
| tree.pos); |
| separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos); |
| } else if (tree.sym.getKind() == ElementKind.EXCEPTION_PARAMETER) { |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.exceptionParameter(currentLambda, |
| tree.pos); |
| separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos); |
| } else if (tree.sym.getKind() == ElementKind.RESOURCE_VARIABLE) { |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.resourceVariable(currentLambda, |
| tree.pos); |
| separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos); |
| } else if (tree.sym.getKind() == ElementKind.ENUM_CONSTANT) { |
| // No type annotations can occur here. |
| } else { |
| // There is nothing else in a variable declaration that needs separation. |
| Assert.error("Unhandled variable kind"); |
| } |
| |
| scan(tree.mods); |
| scan(tree.vartype); |
| if (!sigOnly) { |
| scan(tree.init); |
| } |
| } |
| |
| @Override |
| public void visitBlock(JCBlock tree) { |
| // Do not descend into top-level blocks when only interested |
| // in the signature. |
| if (!sigOnly) { |
| scan(tree.stats); |
| } |
| } |
| |
| @Override |
| public void visitAnnotatedType(JCAnnotatedType tree) { |
| push(tree); |
| findPosition(tree, tree, tree.annotations); |
| pop(); |
| super.visitAnnotatedType(tree); |
| } |
| |
| @Override |
| public void visitTypeParameter(JCTypeParameter tree) { |
| findPosition(tree, peek2(), tree.annotations); |
| super.visitTypeParameter(tree); |
| } |
| |
| private void copyNewClassAnnotationsToOwner(JCNewClass tree) { |
| Symbol sym = tree.def.sym; |
| final TypeAnnotationPosition pos = |
| TypeAnnotationPosition.newObj(tree.pos); |
| ListBuffer<Attribute.TypeCompound> newattrs = new ListBuffer<>(); |
| |
| for (Attribute.TypeCompound old : sym.getRawTypeAttributes()) { |
| newattrs.append(new Attribute.TypeCompound(old.type, old.values, |
| pos)); |
| } |
| |
| sym.owner.appendUniqueTypeAttributes(newattrs.toList()); |
| } |
| |
| @Override |
| public void visitNewClass(JCNewClass tree) { |
| if (tree.def != null && |
| !tree.def.mods.annotations.isEmpty()) { |
| JCClassDecl classdecl = tree.def; |
| TypeAnnotationPosition pos; |
| |
| if (classdecl.extending == tree.clazz) { |
| pos = TypeAnnotationPosition.classExtends(tree.pos); |
| } else if (classdecl.implementing.contains(tree.clazz)) { |
| final int index = classdecl.implementing.indexOf(tree.clazz); |
| pos = TypeAnnotationPosition.classExtends(index, tree.pos); |
| } else { |
| // In contrast to CLASS elsewhere, typarams cannot occur here. |
| throw new AssertionError("Could not determine position of tree " + tree); |
| } |
| Type before = classdecl.sym.type; |
| separateAnnotationsKinds(classdecl, tree.clazz.type, classdecl.sym, pos); |
| copyNewClassAnnotationsToOwner(tree); |
| // classdecl.sym.type now contains an annotated type, which |
| // is not what we want there. |
| // TODO: should we put this type somewhere in the superclass/interface? |
| classdecl.sym.type = before; |
| } |
| |
| scan(tree.encl); |
| scan(tree.typeargs); |
| scan(tree.clazz); |
| scan(tree.args); |
| |
| // The class body will already be scanned. |
| // scan(tree.def); |
| } |
| |
| @Override |
| public void visitNewArray(JCNewArray tree) { |
| findPosition(tree, tree, tree.annotations); |
| int dimAnnosCount = tree.dimAnnotations.size(); |
| ListBuffer<TypePathEntry> depth = new ListBuffer<>(); |
| |
| // handle annotations associated with dimensions |
| for (int i = 0; i < dimAnnosCount; ++i) { |
| ListBuffer<TypePathEntry> location = |
| new ListBuffer<TypePathEntry>(); |
| if (i != 0) { |
| depth = depth.append(TypePathEntry.ARRAY); |
| location = location.appendList(depth.toList()); |
| } |
| final TypeAnnotationPosition p = |
| TypeAnnotationPosition.newObj(location.toList(), |
| currentLambda, |
| tree.pos); |
| |
| setTypeAnnotationPos(tree.dimAnnotations.get(i), p); |
| } |
| |
| // handle "free" annotations |
| // int i = dimAnnosCount == 0 ? 0 : dimAnnosCount - 1; |
| // TODO: is depth.size == i here? |
| JCExpression elemType = tree.elemtype; |
| depth = depth.append(TypePathEntry.ARRAY); |
| while (elemType != null) { |
| if (elemType.hasTag(JCTree.Tag.ANNOTATED_TYPE)) { |
| JCAnnotatedType at = (JCAnnotatedType)elemType; |
| final ListBuffer<TypePathEntry> locationbuf = |
| locateNestedTypes(elemType.type, |
| new ListBuffer<TypePathEntry>()); |
| final List<TypePathEntry> location = |
| locationbuf.toList().prependList(depth.toList()); |
| final TypeAnnotationPosition p = |
| TypeAnnotationPosition.newObj(location, currentLambda, |
| tree.pos); |
| setTypeAnnotationPos(at.annotations, p); |
| elemType = at.underlyingType; |
| } else if (elemType.hasTag(JCTree.Tag.TYPEARRAY)) { |
| depth = depth.append(TypePathEntry.ARRAY); |
| elemType = ((JCArrayTypeTree)elemType).elemtype; |
| } else if (elemType.hasTag(JCTree.Tag.SELECT)) { |
| elemType = ((JCFieldAccess)elemType).selected; |
| } else { |
| break; |
| } |
| } |
| scan(tree.elems); |
| } |
| |
| |
| private void findTypeCompoundPosition(JCTree tree, JCTree frame, List<Attribute.TypeCompound> annotations) { |
| if (!annotations.isEmpty()) { |
| final TypeAnnotationPosition p = |
| resolveFrame(tree, frame, frames, currentLambda, 0, new ListBuffer<>()); |
| for (TypeCompound tc : annotations) |
| tc.position = p; |
| } |
| } |
| |
| private void findPosition(JCTree tree, JCTree frame, List<JCAnnotation> annotations) { |
| if (!annotations.isEmpty()) |
| { |
| final TypeAnnotationPosition p = |
| resolveFrame(tree, frame, frames, currentLambda, 0, new ListBuffer<>()); |
| |
| setTypeAnnotationPos(annotations, p); |
| } |
| } |
| |
| private void setTypeAnnotationPos(List<JCAnnotation> annotations, TypeAnnotationPosition position) |
| { |
| // attribute might be null during DeferredAttr; |
| // we will be back later. |
| for (JCAnnotation anno : annotations) { |
| if (anno.attribute != null) |
| ((Attribute.TypeCompound) anno.attribute).position = position; |
| } |
| } |
| |
| |
| @Override |
| public String toString() { |
| return super.toString() + ": sigOnly: " + sigOnly; |
| } |
| } |
| } |
