1 /*

     2  * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javac.code;

    27 

    28 import javax.lang.model.element.Element;

    29 import javax.lang.model.element.ElementKind;

    30 import javax.lang.model.type.TypeKind;

    31 

    32 import javax.tools.JavaFileObject;

    33 

    34 import com.sun.tools.javac.code.Attribute.TypeCompound;

    35 import com.sun.tools.javac.code.Type.ArrayType;

    36 import com.sun.tools.javac.code.Type.CapturedType;

    37 import com.sun.tools.javac.code.Type.ClassType;

    38 import com.sun.tools.javac.code.Type.ErrorType;

    39 import com.sun.tools.javac.code.Type.ForAll;

    40 import com.sun.tools.javac.code.Type.MethodType;

    41 import com.sun.tools.javac.code.Type.PackageType;

    42 import com.sun.tools.javac.code.Type.TypeVar;

    43 import com.sun.tools.javac.code.Type.UndetVar;

    44 import com.sun.tools.javac.code.Type.Visitor;

    45 import com.sun.tools.javac.code.Type.WildcardType;

    46 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry;

    47 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntryKind;

    48 import com.sun.tools.javac.code.Symbol.VarSymbol;

    49 import com.sun.tools.javac.code.Symbol.MethodSymbol;

    50 import com.sun.tools.javac.comp.Annotate;

    51 import com.sun.tools.javac.comp.Annotate.Worker;

    52 import com.sun.tools.javac.comp.Attr;

    53 import com.sun.tools.javac.comp.AttrContext;

    54 import com.sun.tools.javac.comp.Env;

    55 import com.sun.tools.javac.tree.JCTree;

    56 import com.sun.tools.javac.tree.TreeInfo;

    57 import com.sun.tools.javac.tree.JCTree.JCBlock;

    58 import com.sun.tools.javac.tree.JCTree.JCClassDecl;

    59 import com.sun.tools.javac.tree.JCTree.JCExpression;

    60 import com.sun.tools.javac.tree.JCTree.JCLambda;

    61 import com.sun.tools.javac.tree.JCTree.JCMethodDecl;

    62 import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;

    63 import com.sun.tools.javac.tree.JCTree.JCNewClass;

    64 import com.sun.tools.javac.tree.JCTree.JCTypeApply;

    65 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;

    66 import com.sun.tools.javac.tree.TreeScanner;

    67 import com.sun.tools.javac.tree.JCTree.*;

    68 import com.sun.tools.javac.util.Assert;

    69 import com.sun.tools.javac.util.Context;

    70 import com.sun.tools.javac.util.List;

    71 import com.sun.tools.javac.util.ListBuffer;

    72 import com.sun.tools.javac.util.Log;

    73 import com.sun.tools.javac.util.Names;

    74 import com.sun.tools.javac.util.Options;

    75 

    76 /**

    77  * Contains operations specific to processing type annotations.

    78  * This class has two functions:

    79  * separate declaration from type annotations and insert the type

    80  * annotations to their types;

    81  * and determine the TypeAnnotationPositions for all type annotations.

    82  */

    83 public class TypeAnnotations {

    84     protected static final Context.Key<TypeAnnotations> typeAnnosKey = new Context.Key<>();

    85 

    86     public static TypeAnnotations instance(Context context) {

    87         TypeAnnotations instance = context.get(typeAnnosKey);

    88         if (instance == null)

    89             instance = new TypeAnnotations(context);

    90         return instance;

    91     }

    92 

    93     final Log log;

    94     final Names names;

    95     final Symtab syms;

    96     final Annotate annotate;

    97     final Attr attr;

    98 

    99     protected TypeAnnotations(Context context) {

   100         context.put(typeAnnosKey, this);

   101         names = Names.instance(context);

   102         log = Log.instance(context);

   103         syms = Symtab.instance(context);

   104         annotate = Annotate.instance(context);

   105         attr = Attr.instance(context);

   106         Options options = Options.instance(context);

   107     }

   108 

   109     /**

   110      * Separate type annotations from declaration annotations and

   111      * determine the correct positions for type annotations.

   112      * This version only visits types in signatures and should be

   113      * called from MemberEnter.

   114      * The method takes the Annotate object as parameter and

   115      * adds an Annotate.Worker to the correct Annotate queue for

   116      * later processing.

   117      */

   118     public void organizeTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {

   119         annotate.afterRepeated( new Worker() {

   120             @Override

   121             public void run() {

   122                 JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);

   123 

   124                 try {

   125                     new TypeAnnotationPositions(true).scan(tree);

   126                 } finally {

   127                     log.useSource(oldSource);

   128                 }

   129             }

   130         } );

   131     }

   132 

   133     public void validateTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {

   134         annotate.validate(new Worker() { //validate annotations

   135             @Override

   136             public void run() {

   137                 JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);

   138 

   139                 try {

   140                     attr.validateTypeAnnotations(tree, true);

   141                 } finally {

   142                     log.useSource(oldSource);

   143                 }

   144             }

   145         } );

   146     }

   147 

   148     /**

   149      * This version only visits types in bodies, that is, field initializers,

   150      * top-level blocks, and method bodies, and should be called from Attr.

   151      */

   152     public void organizeTypeAnnotationsBodies(JCClassDecl tree) {

   153         new TypeAnnotationPositions(false).scan(tree);

   154     }

   155 

   156     public enum AnnotationType { DECLARATION, TYPE, BOTH }

   157 

   158     /**

   159      * Determine whether an annotation is a declaration annotation,

   160      * a type annotation, or both.

   161      */

   162     public AnnotationType annotationType(Attribute.Compound a, Symbol s) {

   163         Attribute.Compound atTarget =

   164             a.type.tsym.attribute(syms.annotationTargetType.tsym);

   165         if (atTarget == null) {

   166             return inferTargetMetaInfo(a, s);

   167         }

   168         Attribute atValue = atTarget.member(names.value);

   169         if (!(atValue instanceof Attribute.Array)) {

   170             Assert.error("annotationType(): bad @Target argument " + atValue +

   171                     " (" + atValue.getClass() + ")");

   172             return AnnotationType.DECLARATION; // error recovery

   173         }

   174         Attribute.Array arr = (Attribute.Array) atValue;

   175         boolean isDecl = false, isType = false;

   176         for (Attribute app : arr.values) {

   177             if (!(app instanceof Attribute.Enum)) {

   178                 Assert.error("annotationType(): unrecognized Attribute kind " + app +

   179                         " (" + app.getClass() + ")");

   180                 isDecl = true;

   181                 continue;

   182             }

   183             Attribute.Enum e = (Attribute.Enum) app;

   184             if (e.value.name == names.TYPE) {

   185                 if (s.kind == Kinds.TYP)

   186                     isDecl = true;

   187             } else if (e.value.name == names.FIELD) {

   188                 if (s.kind == Kinds.VAR &&

   189                         s.owner.kind != Kinds.MTH)

   190                     isDecl = true;

   191             } else if (e.value.name == names.METHOD) {

   192                 if (s.kind == Kinds.MTH &&

   193                         !s.isConstructor())

   194                     isDecl = true;

   195             } else if (e.value.name == names.PARAMETER) {

   196                 if (s.kind == Kinds.VAR &&

   197                         s.owner.kind == Kinds.MTH &&

   198                         (s.flags() & Flags.PARAMETER) != 0)

   199                     isDecl = true;

   200             } else if (e.value.name == names.CONSTRUCTOR) {

   201                 if (s.kind == Kinds.MTH &&

   202                         s.isConstructor())

   203                     isDecl = true;

   204             } else if (e.value.name == names.LOCAL_VARIABLE) {

   205                 if (s.kind == Kinds.VAR &&

   206                         s.owner.kind == Kinds.MTH &&

   207                         (s.flags() & Flags.PARAMETER) == 0)

   208                     isDecl = true;

   209             } else if (e.value.name == names.ANNOTATION_TYPE) {

   210                 if (s.kind == Kinds.TYP &&

   211                         (s.flags() & Flags.ANNOTATION) != 0)

   212                     isDecl = true;

   213             } else if (e.value.name == names.PACKAGE) {

   214                 if (s.kind == Kinds.PCK)

   215                     isDecl = true;

   216             } else if (e.value.name == names.TYPE_USE) {

   217                 if (s.kind == Kinds.TYP ||

   218                         s.kind == Kinds.VAR ||

   219                         (s.kind == Kinds.MTH && !s.isConstructor() &&

   220                         !s.type.getReturnType().hasTag(TypeTag.VOID)) ||

   221                         (s.kind == Kinds.MTH && s.isConstructor()))

   222                     isType = true;

   223             } else if (e.value.name == names.TYPE_PARAMETER) {

   224                 /* Irrelevant in this case */

   225                 // TYPE_PARAMETER doesn't aid in distinguishing between

   226                 // Type annotations and declaration annotations on an

   227                 // Element

   228             } else {

   229                 Assert.error("annotationType(): unrecognized Attribute name " + e.value.name +

   230                         " (" + e.value.name.getClass() + ")");

   231                 isDecl = true;

   232             }

   233         }

   234         if (isDecl && isType) {

   235             return AnnotationType.BOTH;

   236         } else if (isType) {

   237             return AnnotationType.TYPE;

   238         } else {

   239             return AnnotationType.DECLARATION;

   240         }

   241     }

   242 

   243     /** Infer the target annotation kind, if none is give.

   244      * We only infer declaration annotations.

   245      */

   246     private static AnnotationType inferTargetMetaInfo(Attribute.Compound a, Symbol s) {

   247         return AnnotationType.DECLARATION;

   248     }

   249 

   250 

   251     private class TypeAnnotationPositions extends TreeScanner {

   252 

   253         private final boolean sigOnly;

   254 

   255         TypeAnnotationPositions(boolean sigOnly) {

   256             this.sigOnly = sigOnly;

   257         }

   258 

   259         /*

   260          * When traversing the AST we keep the "frames" of visited

   261          * trees in order to determine the position of annotations.

   262          */

   263         private ListBuffer<JCTree> frames = new ListBuffer<>();

   264 

   265         protected void push(JCTree t) { frames = frames.prepend(t); }

   266         protected JCTree pop() { return frames.next(); }

   267         // could this be frames.elems.tail.head?

   268         private JCTree peek2() { return frames.toList().tail.head; }

   269 

   270         @Override

   271         public void scan(JCTree tree) {

   272             push(tree);

   273             super.scan(tree);

   274             pop();

   275         }

   276 

   277         /**

   278          * Separates type annotations from declaration annotations.

   279          * This step is needed because in certain locations (where declaration

   280          * and type annotations can be mixed, e.g. the type of a field)

   281          * we never build an JCAnnotatedType. This step finds these

   282          * annotations and marks them as if they were part of the type.

   283          */

   284         private void separateAnnotationsKinds(JCTree typetree, Type type, Symbol sym,

   285                 TypeAnnotationPosition pos) {

   286             List<Attribute.Compound> annotations = sym.getRawAttributes();

   287             ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<>();

   288             ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<>();

   289             ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<>();

   290 

   291             for (Attribute.Compound a : annotations) {

   292                 switch (annotationType(a, sym)) {

   293                 case DECLARATION:

   294                     declAnnos.append(a);

   295                     break;

   296                 case BOTH: {

   297                     declAnnos.append(a);

   298                     Attribute.TypeCompound ta = toTypeCompound(a, pos);

   299                     typeAnnos.append(ta);

   300                     break;

   301                 }

   302                 case TYPE: {

   303                     Attribute.TypeCompound ta = toTypeCompound(a, pos);

   304                     typeAnnos.append(ta);

   305                     // Also keep track which annotations are only type annotations

   306                     onlyTypeAnnos.append(ta);

   307                     break;

   308                 }

   309                 }

   310             }

   311 

   312             sym.resetAnnotations();

   313             sym.setDeclarationAttributes(declAnnos.toList());

   314 

   315             if (typeAnnos.isEmpty()) {

   316                 return;

   317             }

   318 

   319             List<Attribute.TypeCompound> typeAnnotations = typeAnnos.toList();

   320 

   321             if (type == null) {

   322                 // When type is null, put the type annotations to the symbol.

   323                 // This is used for constructor return annotations, for which

   324                 // we use the type of the enclosing class.

   325                 type = sym.getEnclosingElement().asType();

   326 

   327                 // Declaration annotations are always allowed on constructor returns.

   328                 // Therefore, use typeAnnotations instead of onlyTypeAnnos.

   329                 type = typeWithAnnotations(typetree, type, typeAnnotations, typeAnnotations);

   330                 // Note that we don't use the result, the call to

   331                 // typeWithAnnotations side-effects the type annotation positions.

   332                 // This is important for constructors of nested classes.

   333                 sym.appendUniqueTypeAttributes(typeAnnotations);

   334                 return;

   335             }

   336 

   337             // type is non-null and annotations are added to that type

   338             type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList());

   339 

   340             if (sym.getKind() == ElementKind.METHOD) {

   341                 sym.type.asMethodType().restype = type;

   342             } else if (sym.getKind() == ElementKind.PARAMETER) {

   343                 sym.type = type;

   344                 if (sym.getQualifiedName().equals(names._this)) {

   345                     sym.owner.type.asMethodType().recvtype = type;

   346                     // note that the typeAnnotations will also be added to the owner below.

   347                 } else {

   348                     MethodType methType = sym.owner.type.asMethodType();

   349                     List<VarSymbol> params = ((MethodSymbol)sym.owner).params;

   350                     List<Type> oldArgs = methType.argtypes;

   351                     ListBuffer<Type> newArgs = new ListBuffer<>();

   352                     while (params.nonEmpty()) {

   353                         if (params.head == sym) {

   354                             newArgs.add(type);

   355                         } else {

   356                             newArgs.add(oldArgs.head);

   357                         }

   358                         oldArgs = oldArgs.tail;

   359                         params = params.tail;

   360                     }

   361                     methType.argtypes = newArgs.toList();

   362                 }

   363             } else {

   364                 sym.type = type;

   365             }

   366 

   367             sym.appendUniqueTypeAttributes(typeAnnotations);

   368 

   369             if (sym.getKind() == ElementKind.PARAMETER ||

   370                 sym.getKind() == ElementKind.LOCAL_VARIABLE ||

   371                 sym.getKind() == ElementKind.RESOURCE_VARIABLE ||

   372                 sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {

   373                 // Make sure all type annotations from the symbol are also

   374                 // on the owner.

   375                 sym.owner.appendUniqueTypeAttributes(sym.getRawTypeAttributes());

   376             }

   377         }

   378 

   379         // This method has a similar purpose as

   380         // {@link com.sun.tools.javac.parser.JavacParser.insertAnnotationsToMostInner(JCExpression, List<JCTypeAnnotation>, boolean)}

   381         // We found a type annotation in a declaration annotation position,

   382         // for example, on the return type.

   383         // Such an annotation is _not_ part of an JCAnnotatedType tree and we therefore

   384         // need to set its position explicitly.

   385         // The method returns a copy of type that contains these annotations.

   386         //

   387         // As a side effect the method sets the type annotation position of "annotations".

   388         // Note that it is assumed that all annotations share the same position.

   389         private Type typeWithAnnotations(final JCTree typetree, final Type type,

   390                 final List<Attribute.TypeCompound> annotations,

   391                 final List<Attribute.TypeCompound> onlyTypeAnnotations) {

   392             //System.err.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s, onlyTypeAnnotations: %s)%n",

   393             //         typetree, type, annotations, onlyTypeAnnotations);

   394             if (annotations.isEmpty()) {

   395                 return type;

   396             }

   397             if (type.hasTag(TypeTag.ARRAY)) {

   398                 Type.ArrayType arType = (Type.ArrayType) type;

   399                 Type.ArrayType tomodify = new Type.ArrayType(null, arType.tsym,

   400                                                              Type.noAnnotations);

   401                 Type toreturn;

   402                 if (type.isAnnotated()) {

   403                     toreturn = tomodify.annotatedType(type.getAnnotationMirrors());

   404                 } else {

   405                     toreturn = tomodify;

   406                 }

   407 

   408                 JCArrayTypeTree arTree = arrayTypeTree(typetree);

   409 

   410                 ListBuffer<TypePathEntry> depth = new ListBuffer<>();

   411                 depth = depth.append(TypePathEntry.ARRAY);

   412                 while (arType.elemtype.hasTag(TypeTag.ARRAY)) {

   413                     if (arType.elemtype.isAnnotated()) {

   414                         Type aelemtype = arType.elemtype;

   415                         arType = (Type.ArrayType) aelemtype;

   416                         ArrayType prevToMod = tomodify;

   417                         tomodify = new Type.ArrayType(null, arType.tsym,

   418                                                       Type.noAnnotations);

   419                         prevToMod.elemtype = tomodify.annotatedType(arType.elemtype.getAnnotationMirrors());

   420                     } else {

   421                         arType = (Type.ArrayType) arType.elemtype;

   422                         tomodify.elemtype = new Type.ArrayType(null, arType.tsym,

   423                                                                Type.noAnnotations);

   424                         tomodify = (Type.ArrayType) tomodify.elemtype;

   425                     }

   426                     arTree = arrayTypeTree(arTree.elemtype);

   427                     depth = depth.append(TypePathEntry.ARRAY);

   428                 }

   429                 Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations, onlyTypeAnnotations);

   430                 tomodify.elemtype = arelemType;

   431                 {

   432                     // All annotations share the same position; modify the first one.

   433                     Attribute.TypeCompound a = annotations.get(0);

   434                     TypeAnnotationPosition p = a.position;

   435                     p.location = p.location.prependList(depth.toList());

   436                 }

   437                 typetree.type = toreturn;

   438                 return toreturn;

   439             } else if (type.hasTag(TypeTag.TYPEVAR)) {

   440                 // Nothing to do for type variables.

   441                 return type;

   442             } else if (type.getKind() == TypeKind.UNION) {

   443                 // There is a TypeKind, but no TypeTag.

   444                 JCTypeUnion tutree = (JCTypeUnion) typetree;

   445                 JCExpression fst = tutree.alternatives.get(0);

   446                 Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations);

   447                 fst.type = res;

   448                 // TODO: do we want to set res as first element in uct.alternatives?

   449                 // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;

   450                 // Return the un-annotated union-type.

   451                 return type;

   452             } else {

   453                 Type enclTy = type;

   454                 Element enclEl = type.asElement();

   455                 JCTree enclTr = typetree;

   456 

   457                 while (enclEl != null &&

   458                         enclEl.getKind() != ElementKind.PACKAGE &&

   459                         enclTy != null &&

   460                         enclTy.getKind() != TypeKind.NONE &&

   461                         enclTy.getKind() != TypeKind.ERROR &&

   462                         (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT ||

   463                          enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE ||

   464                          enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) {

   465                     // Iterate also over the type tree, not just the type: the type is already

   466                     // completely resolved and we cannot distinguish where the annotation

   467                     // belongs for a nested type.

   468                     if (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT) {

   469                         // only change encl in this case.

   470                         enclTy = enclTy.getEnclosingType();

   471                         enclEl = enclEl.getEnclosingElement();

   472                         enclTr = ((JCFieldAccess)enclTr).getExpression();

   473                     } else if (enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE) {

   474                         enclTr = ((JCTypeApply)enclTr).getType();

   475                     } else {

   476                         // only other option because of while condition

   477                         enclTr = ((JCAnnotatedType)enclTr).getUnderlyingType();

   478                     }

   479                 }

   480 

   481                 /** We are trying to annotate some enclosing type,

   482                  * but nothing more exists.

   483                  */

   484                 if (enclTy != null &&

   485                         enclTy.hasTag(TypeTag.NONE)) {

   486                     switch (onlyTypeAnnotations.size()) {

   487                     case 0:

   488                         // Don't issue an error if all type annotations are

   489                         // also declaration annotations.

   490                         // If the annotations are also declaration annotations, they are

   491                         // illegal as type annotations but might be legal as declaration annotations.

   492                         // The normal declaration annotation checks make sure that the use is valid.

   493                         break;

   494                     case 1:

   495                         log.error(typetree.pos(), "cant.type.annotate.scoping.1",

   496                                 onlyTypeAnnotations);

   497                         break;

   498                     default:

   499                         log.error(typetree.pos(), "cant.type.annotate.scoping",

   500                                 onlyTypeAnnotations);

   501                     }

   502                     return type;

   503                 }

   504 

   505                 // At this point we have visited the part of the nested

   506                 // type that is written in the source code.

   507                 // Now count from here to the actual top-level class to determine

   508                 // the correct nesting.

   509 

   510                 // The genericLocation for the annotation.

   511                 ListBuffer<TypePathEntry> depth = new ListBuffer<>();

   512 

   513                 Type topTy = enclTy;

   514                 while (enclEl != null &&

   515                         enclEl.getKind() != ElementKind.PACKAGE &&

   516                         topTy != null &&

   517                         topTy.getKind() != TypeKind.NONE &&

   518                         topTy.getKind() != TypeKind.ERROR) {

   519                     topTy = topTy.getEnclosingType();

   520                     enclEl = enclEl.getEnclosingElement();

   521 

   522                     if (topTy != null && topTy.getKind() != TypeKind.NONE) {

   523                         // Only count enclosing types.

   524                         depth = depth.append(TypePathEntry.INNER_TYPE);

   525                     }

   526                 }

   527 

   528                 if (depth.nonEmpty()) {

   529                     // Only need to change the annotation positions

   530                     // if they are on an enclosed type.

   531                     // All annotations share the same position; modify the first one.

   532                     Attribute.TypeCompound a = annotations.get(0);

   533                     TypeAnnotationPosition p = a.position;

   534                     p.location = p.location.appendList(depth.toList());

   535                 }

   536 

   537                 Type ret = typeWithAnnotations(type, enclTy, annotations);

   538                 typetree.type = ret;

   539                 return ret;

   540             }

   541         }

   542 

   543         private JCArrayTypeTree arrayTypeTree(JCTree typetree) {

   544             if (typetree.getKind() == JCTree.Kind.ARRAY_TYPE) {

   545                 return (JCArrayTypeTree) typetree;

   546             } else if (typetree.getKind() == JCTree.Kind.ANNOTATED_TYPE) {

   547                 return (JCArrayTypeTree) ((JCAnnotatedType)typetree).underlyingType;

   548             } else {

   549                 Assert.error("Could not determine array type from type tree: " + typetree);

   550                 return null;

   551             }

   552         }

   553 

   554         /** Return a copy of the first type that only differs by

   555          * inserting the annotations to the left-most/inner-most type

   556          * or the type given by stopAt.

   557          *

   558          * We need the stopAt parameter to know where on a type to

   559          * put the annotations.

   560          * If we have nested classes Outer > Middle > Inner, and we

   561          * have the source type "@A Middle.Inner", we will invoke

   562          * this method with type = Outer.Middle.Inner,

   563          * stopAt = Middle.Inner, and annotations = @A.

   564          *

   565          * @param type The type to copy.

   566          * @param stopAt The type to stop at.

   567          * @param annotations The annotations to insert.

   568          * @return A copy of type that contains the annotations.

   569          */

   570         private Type typeWithAnnotations(final Type type,

   571                 final Type stopAt,

   572                 final List<Attribute.TypeCompound> annotations) {

   573             //System.err.println("typeWithAnnotations " + type + " " + annotations + " stopAt " + stopAt);

   574             Visitor<Type, List<TypeCompound>> visitor =

   575                     new Type.Visitor<Type, List<Attribute.TypeCompound>>() {

   576                 @Override

   577                 public Type visitClassType(ClassType t, List<TypeCompound> s) {

   578                     // assert that t.constValue() == null?

   579                     if (t == stopAt ||

   580                         t.getEnclosingType() == Type.noType) {

   581                         return t.annotatedType(s);

   582                     } else {

   583                         ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),

   584                                                       t.typarams_field, t.tsym,

   585                                                       t.getAnnotationMirrors());

   586                         ret.all_interfaces_field = t.all_interfaces_field;

   587                         ret.allparams_field = t.allparams_field;

   588                         ret.interfaces_field = t.interfaces_field;

   589                         ret.rank_field = t.rank_field;

   590                         ret.supertype_field = t.supertype_field;

   591                         return ret;

   592                     }

   593                 }

   594 

   595                 @Override

   596                 public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {

   597                     return t.annotatedType(s);

   598                 }

   599 

   600                 @Override

   601                 public Type visitArrayType(ArrayType t, List<TypeCompound> s) {

   602                     ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym,

   603                                                   t.getAnnotationMirrors());

   604                     return ret;

   605                 }

   606 

   607                 @Override

   608                 public Type visitMethodType(MethodType t, List<TypeCompound> s) {

   609                     // Impossible?

   610                     return t;

   611                 }

   612 

   613                 @Override

   614                 public Type visitPackageType(PackageType t, List<TypeCompound> s) {

   615                     // Impossible?

   616                     return t;

   617                 }

   618 

   619                 @Override

   620                 public Type visitTypeVar(TypeVar t, List<TypeCompound> s) {

   621                     return t.annotatedType(s);

   622                 }

   623 

   624                 @Override

   625                 public Type visitCapturedType(CapturedType t, List<TypeCompound> s) {

   626                     return t.annotatedType(s);

   627                 }

   628 

   629                 @Override

   630                 public Type visitForAll(ForAll t, List<TypeCompound> s) {

   631                     // Impossible?

   632                     return t;

   633                 }

   634 

   635                 @Override

   636                 public Type visitUndetVar(UndetVar t, List<TypeCompound> s) {

   637                     // Impossible?

   638                     return t;

   639                 }

   640 

   641                 @Override

   642                 public Type visitErrorType(ErrorType t, List<TypeCompound> s) {

   643                     return t.annotatedType(s);

   644                 }

   645 

   646                 @Override

   647                 public Type visitType(Type t, List<TypeCompound> s) {

   648                     return t.annotatedType(s);

   649                 }

   650             };

   651 

   652             return type.accept(visitor, annotations);

   653         }

   654 

   655         private Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) {

   656             // It is safe to alias the position.

   657             return new Attribute.TypeCompound(a, p);

   658         }

   659 

   660 

   661         /* This is the beginning of the second part of organizing

   662          * type annotations: determine the type annotation positions.

   663          */

   664 

   665         // This method is considered deprecated, and will be removed

   666         // in the near future.  Don't use it for anything new.

   667         private TypeAnnotationPosition

   668             resolveFrame(JCTree tree,

   669                          JCTree frame,

   670                          List<JCTree> path,

   671                          JCLambda currentLambda,

   672                          int outer_type_index,

   673                          ListBuffer<TypePathEntry> location) {

   674             /*

   675             System.out.println("Resolving tree: " + tree + " kind: " + tree.getKind());

   676             System.out.println("    Framing tree: " + frame + " kind: " + frame.getKind());

   677             */

   678 

   679             // Note that p.offset is set in

   680             // com.sun.tools.javac.jvm.Gen.setTypeAnnotationPositions(int)

   681 

   682             switch (frame.getKind()) {

   683                 case TYPE_CAST:

   684                     return TypeAnnotationPosition.typeCast(location.toList(),

   685                                                            currentLambda,

   686                                                            outer_type_index,

   687                                                            frame.pos);

   688 

   689                 case INSTANCE_OF:

   690                     return TypeAnnotationPosition.instanceOf(location.toList(),

   691                                                              currentLambda,

   692                                                              frame.pos);

   693 

   694                 case NEW_CLASS:

   695                     final JCNewClass frameNewClass = (JCNewClass) frame;

   696                     if (frameNewClass.def != null) {

   697                         // Special handling for anonymous class instantiations

   698                         final JCClassDecl frameClassDecl = frameNewClass.def;

   699                         if (frameClassDecl.extending == tree) {

   700                             return TypeAnnotationPosition

   701                                 .classExtends(location.toList(), currentLambda,

   702                                               frame.pos);

   703                         } else if (frameClassDecl.implementing.contains(tree)) {

   704                             final int type_index =

   705                                 frameClassDecl.implementing.indexOf(tree);

   706                             return TypeAnnotationPosition

   707                                 .classExtends(location.toList(), currentLambda,

   708                                               type_index, frame.pos);

   709                         } else {

   710                             // In contrast to CLASS below, typarams cannot occur here.

   711                             throw new AssertionError("Could not determine position of tree " + tree +

   712                                                      " within frame " + frame);

   713                         }

   714                     } else if (frameNewClass.typeargs.contains(tree)) {

   715                         final int type_index =

   716                             frameNewClass.typeargs.indexOf(tree);

   717                         return TypeAnnotationPosition

   718                             .constructorInvocationTypeArg(location.toList(),

   719                                                           currentLambda,

   720                                                           type_index,

   721                                                           frame.pos);

   722                     } else {

   723                         return TypeAnnotationPosition

   724                             .newObj(location.toList(), currentLambda,

   725                                     frame.pos);

   726                     }

   727 

   728                 case NEW_ARRAY:

   729                     return TypeAnnotationPosition

   730                         .newObj(location.toList(), currentLambda, frame.pos);

   731 

   732                 case ANNOTATION_TYPE:

   733                 case CLASS:

   734                 case ENUM:

   735                 case INTERFACE:

   736                     if (((JCClassDecl)frame).extending == tree) {

   737                         return TypeAnnotationPosition

   738                             .classExtends(location.toList(), currentLambda,

   739                                           frame.pos);

   740                     } else if (((JCClassDecl)frame).implementing.contains(tree)) {

   741                         final int type_index =

   742                             ((JCClassDecl)frame).implementing.indexOf(tree);

   743                         return TypeAnnotationPosition

   744                             .classExtends(location.toList(), currentLambda,

   745                                           type_index, frame.pos);

   746                     } else if (((JCClassDecl)frame).typarams.contains(tree)) {

   747                         final int parameter_index =

   748                             ((JCClassDecl)frame).typarams.indexOf(tree);

   749                         return TypeAnnotationPosition

   750                             .typeParameter(location.toList(), currentLambda,

   751                                            parameter_index, frame.pos);

   752                     } else {

   753                         throw new AssertionError("Could not determine position of tree " +

   754                                                  tree + " within frame " + frame);

   755                     }

   756 

   757                 case METHOD: {

   758                     final JCMethodDecl frameMethod = (JCMethodDecl) frame;

   759                     if (frameMethod.thrown.contains(tree)) {

   760                         final int type_index = frameMethod.thrown.indexOf(tree);

   761                         return TypeAnnotationPosition

   762                             .methodThrows(location.toList(), currentLambda,

   763                                           type_index, frame.pos);

   764                     } else if (frameMethod.restype == tree) {

   765                         return TypeAnnotationPosition

   766                             .methodReturn(location.toList(), currentLambda,

   767                                           frame.pos);

   768                     } else if (frameMethod.typarams.contains(tree)) {

   769                         final int parameter_index =

   770                             frameMethod.typarams.indexOf(tree);

   771                         return TypeAnnotationPosition

   772                             .methodTypeParameter(location.toList(),

   773                                                  currentLambda,

   774                                                  parameter_index, frame.pos);

   775                     } else {

   776                         throw new AssertionError("Could not determine position of tree " + tree +

   777                                                  " within frame " + frame);

   778                     }

   779                 }

   780 

   781                 case PARAMETERIZED_TYPE: {

   782                     List<JCTree> newPath = path.tail;

   783 

   784                     if (((JCTypeApply)frame).clazz == tree) {

   785                         // generic: RAW; noop

   786                     } else if (((JCTypeApply)frame).arguments.contains(tree)) {

   787                         JCTypeApply taframe = (JCTypeApply) frame;

   788                         int arg = taframe.arguments.indexOf(tree);

   789                         location = location.prepend(

   790                             new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT,

   791                                               arg));

   792 

   793                         Type typeToUse;

   794                         if (newPath.tail != null &&

   795                             newPath.tail.head.hasTag(Tag.NEWCLASS)) {

   796                             // If we are within an anonymous class

   797                             // instantiation, use its type, because it

   798                             // contains a correctly nested type.

   799                             typeToUse = newPath.tail.head.type;

   800                         } else {

   801                             typeToUse = taframe.type;

   802                         }

   803 

   804                         location = locateNestedTypes(typeToUse, location);

   805                     } else {

   806                         throw new AssertionError("Could not determine type argument position of tree " + tree +

   807                                                  " within frame " + frame);

   808                     }

   809 

   810                     return resolveFrame(newPath.head, newPath.tail.head,

   811                                         newPath, currentLambda,

   812                                         outer_type_index, location);

   813                 }

   814 

   815                 case MEMBER_REFERENCE: {

   816                     JCMemberReference mrframe = (JCMemberReference) frame;

   817 

   818                     if (mrframe.expr == tree) {

   819                         switch (mrframe.mode) {

   820                         case INVOKE:

   821                             return TypeAnnotationPosition

   822                                 .methodRef(location.toList(), currentLambda,

   823                                            frame.pos);

   824                         case NEW:

   825                             return TypeAnnotationPosition

   826                                 .constructorRef(location.toList(),

   827                                                 currentLambda,

   828                                                 frame.pos);

   829                         default:

   830                             throw new AssertionError("Unknown method reference mode " + mrframe.mode +

   831                                                      " for tree " + tree + " within frame " + frame);

   832                         }

   833                     } else if (mrframe.typeargs != null &&

   834                             mrframe.typeargs.contains(tree)) {

   835                         final int type_index = mrframe.typeargs.indexOf(tree);

   836                         switch (mrframe.mode) {

   837                         case INVOKE:

   838                             return TypeAnnotationPosition

   839                                 .methodRefTypeArg(location.toList(),

   840                                                   currentLambda,

   841                                                   type_index, frame.pos);

   842                         case NEW:

   843                             return TypeAnnotationPosition

   844                                 .constructorRefTypeArg(location.toList(),

   845                                                        currentLambda,

   846                                                        type_index, frame.pos);

   847                         default:

   848                             throw new AssertionError("Unknown method reference mode " + mrframe.mode +

   849                                                    " for tree " + tree + " within frame " + frame);

   850                         }

   851                     } else {

   852                         throw new AssertionError("Could not determine type argument position of tree " + tree +

   853                                                " within frame " + frame);

   854                     }

   855                 }

   856 

   857                 case ARRAY_TYPE: {

   858                     location = location.prepend(TypePathEntry.ARRAY);

   859                     List<JCTree> newPath = path.tail;

   860                     while (true) {

   861                         JCTree npHead = newPath.tail.head;

   862                         if (npHead.hasTag(JCTree.Tag.TYPEARRAY)) {

   863                             newPath = newPath.tail;

   864                             location = location.prepend(TypePathEntry.ARRAY);

   865                         } else if (npHead.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {

   866                             newPath = newPath.tail;

   867                         } else {

   868                             break;

   869                         }

   870                     }

   871                     return resolveFrame(newPath.head, newPath.tail.head,

   872                                         newPath, currentLambda,

   873                                         outer_type_index, location);

   874                 }

   875 

   876                 case TYPE_PARAMETER:

   877                     if (path.tail.tail.head.hasTag(JCTree.Tag.CLASSDEF)) {

   878                         final JCClassDecl clazz =

   879                             (JCClassDecl)path.tail.tail.head;

   880                         final int parameter_index =

   881                             clazz.typarams.indexOf(path.tail.head);

   882                         final int bound_index =

   883                             ((JCTypeParameter)frame).bounds.get(0)

   884                             .type.isInterface() ?

   885                             ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:

   886                             ((JCTypeParameter)frame).bounds.indexOf(tree);

   887                         return TypeAnnotationPosition

   888                             .typeParameterBound(location.toList(),

   889                                                 currentLambda,

   890                                                 parameter_index, bound_index,

   891                                                 frame.pos);

   892                     } else if (path.tail.tail.head.hasTag(JCTree.Tag.METHODDEF)) {

   893                         final JCMethodDecl method =

   894                             (JCMethodDecl)path.tail.tail.head;

   895                         final int parameter_index =

   896                             method.typarams.indexOf(path.tail.head);

   897                         final int bound_index =

   898                             ((JCTypeParameter)frame).bounds.get(0)

   899                             .type.isInterface() ?

   900                             ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:

   901                             ((JCTypeParameter)frame).bounds.indexOf(tree);

   902                         return TypeAnnotationPosition

   903                             .methodTypeParameterBound(location.toList(),

   904                                                       currentLambda,

   905                                                       parameter_index,

   906                                                       bound_index,

   907                                                       frame.pos);

   908                     } else {

   909                         throw new AssertionError("Could not determine position of tree " + tree +

   910                                                  " within frame " + frame);

   911                     }

   912 

   913                 case VARIABLE:

   914                     VarSymbol v = ((JCVariableDecl)frame).sym;

   915                     if (v.getKind() != ElementKind.FIELD) {

   916                         v.owner.appendUniqueTypeAttributes(v.getRawTypeAttributes());

   917                     }

   918                     switch (v.getKind()) {

   919                         case LOCAL_VARIABLE:

   920                             return TypeAnnotationPosition

   921                                 .localVariable(location.toList(), currentLambda,

   922                                                frame.pos);

   923                         case FIELD:

   924                             return TypeAnnotationPosition.field(location.toList(),

   925                                                                 currentLambda,

   926                                                                 frame.pos);

   927                         case PARAMETER:

   928                             if (v.getQualifiedName().equals(names._this)) {

   929                                 return TypeAnnotationPosition

   930                                     .methodReceiver(location.toList(),

   931                                                     currentLambda,

   932                                                     frame.pos);

   933                             } else {

   934                                 final int parameter_index =

   935                                     methodParamIndex(path, frame);

   936                                 return TypeAnnotationPosition

   937                                     .methodParameter(location.toList(),

   938                                                      currentLambda,

   939                                                      parameter_index,

   940                                                      frame.pos);

   941                             }

   942                         case EXCEPTION_PARAMETER:

   943                             return TypeAnnotationPosition

   944                                 .exceptionParameter(location.toList(),

   945                                                     currentLambda,

   946                                                     frame.pos);

   947                         case RESOURCE_VARIABLE:

   948                             return TypeAnnotationPosition

   949                                 .resourceVariable(location.toList(),

   950                                                   currentLambda,

   951                                                   frame.pos);

   952                         default:

   953                             throw new AssertionError("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());

   954                     }

   955 

   956                 case ANNOTATED_TYPE: {

   957                     if (frame == tree) {

   958                         // This is only true for the first annotated type we see.

   959                         // For any other annotated types along the path, we do

   960                         // not care about inner types.

   961                         JCAnnotatedType atypetree = (JCAnnotatedType) frame;

   962                         final Type utype = atypetree.underlyingType.type;

   963                         Assert.checkNonNull(utype);

   964                         Symbol tsym = utype.tsym;

   965                         if (tsym.getKind().equals(ElementKind.TYPE_PARAMETER) ||

   966                                 utype.getKind().equals(TypeKind.WILDCARD) ||

   967                                 utype.getKind().equals(TypeKind.ARRAY)) {

   968                             // Type parameters, wildcards, and arrays have the declaring

   969                             // class/method as enclosing elements.

   970                             // There is actually nothing to do for them.

   971                         } else {

   972                             location = locateNestedTypes(utype, location);

   973                         }

   974                     }

   975                     List<JCTree> newPath = path.tail;

   976                     return resolveFrame(newPath.head, newPath.tail.head,

   977                                         newPath, currentLambda,

   978                                         outer_type_index, location);

   979                 }

   980 

   981                 case UNION_TYPE: {

   982                     List<JCTree> newPath = path.tail;

   983                     return resolveFrame(newPath.head, newPath.tail.head,

   984                                         newPath, currentLambda,

   985                                         outer_type_index, location);

   986                 }

   987 

   988                 case INTERSECTION_TYPE: {

   989                     JCTypeIntersection isect = (JCTypeIntersection)frame;

   990                     final List<JCTree> newPath = path.tail;

   991                     return resolveFrame(newPath.head, newPath.tail.head,

   992                                         newPath, currentLambda,

   993                                         isect.bounds.indexOf(tree), location);

   994                 }

   995 

   996                 case METHOD_INVOCATION: {

   997                     JCMethodInvocation invocation = (JCMethodInvocation)frame;

   998                     if (!invocation.typeargs.contains(tree)) {

   999                         throw new AssertionError("{" + tree + "} is not an argument in the invocation: " + invocation);

  1000                     }

  1001                     MethodSymbol exsym = (MethodSymbol) TreeInfo.symbol(invocation.getMethodSelect());

  1002                     final int type_index = invocation.typeargs.indexOf(tree);

  1003                     if (exsym == null) {

  1004                         throw new AssertionError("could not determine symbol for {" + invocation + "}");

  1005                     } else if (exsym.isConstructor()) {

  1006                         return TypeAnnotationPosition

  1007                             .constructorInvocationTypeArg(location.toList(),

  1008                                                           currentLambda,

  1009                                                           type_index,

  1010                                                           invocation.pos);

  1011                     } else {

  1012                         return TypeAnnotationPosition

  1013                             .methodInvocationTypeArg(location.toList(),

  1014                                                      currentLambda,

  1015                                                      type_index,

  1016                                                      invocation.pos);

  1017                     }

  1018                 }

  1019 

  1020                 case EXTENDS_WILDCARD:

  1021                 case SUPER_WILDCARD: {

  1022                     // Annotations in wildcard bounds

  1023                     final List<JCTree> newPath = path.tail;

  1024                     return resolveFrame(newPath.head, newPath.tail.head,

  1025                                         newPath, currentLambda,

  1026                                         outer_type_index,

  1027                                         location.prepend(TypePathEntry.WILDCARD));

  1028                 }

  1029 

  1030                 case MEMBER_SELECT: {

  1031                     final List<JCTree> newPath = path.tail;

  1032                     return resolveFrame(newPath.head, newPath.tail.head,

  1033                                         newPath, currentLambda,

  1034                                         outer_type_index, location);

  1035                 }

  1036 

  1037                 default:

  1038                     throw new AssertionError("Unresolved frame: " + frame +

  1039                                              " of kind: " + frame.getKind() +

  1040                                              "\n    Looking for tree: " + tree);

  1041             }

  1042         }

  1043 

  1044         private ListBuffer<TypePathEntry>

  1045             locateNestedTypes(Type type,

  1046                               ListBuffer<TypePathEntry> depth) {

  1047             Type encl = type.getEnclosingType();

  1048             while (encl != null &&

  1049                     encl.getKind() != TypeKind.NONE &&

  1050                     encl.getKind() != TypeKind.ERROR) {

  1051                 depth = depth.prepend(TypePathEntry.INNER_TYPE);

  1052                 encl = encl.getEnclosingType();

  1053             }

  1054             return depth;

  1055         }

  1056 

  1057         private int methodParamIndex(List<JCTree> path, JCTree param) {

  1058             List<JCTree> curr = path;

  1059             while (curr.head.getTag() != Tag.METHODDEF &&

  1060                     curr.head.getTag() != Tag.LAMBDA) {

  1061                 curr = curr.tail;

  1062             }

  1063             if (curr.head.getTag() == Tag.METHODDEF) {

  1064                 JCMethodDecl method = (JCMethodDecl)curr.head;

  1065                 return method.params.indexOf(param);

  1066             } else if (curr.head.getTag() == Tag.LAMBDA) {

  1067                 JCLambda lambda = (JCLambda)curr.head;

  1068                 return lambda.params.indexOf(param);

  1069             } else {

  1070                 Assert.error("methodParamIndex expected to find method or lambda for param: " + param);

  1071                 return -1;

  1072             }

  1073         }

  1074 

  1075         // Each class (including enclosed inner classes) is visited separately.

  1076         // This flag is used to prevent from visiting inner classes.

  1077         private boolean isInClass = false;

  1078 

  1079         @Override

  1080         public void visitClassDef(JCClassDecl tree) {

  1081             if (isInClass)

  1082                 return;

  1083             isInClass = true;

  1084 

  1085             if (sigOnly) {

  1086                 scan(tree.mods);

  1087                 scan(tree.typarams);

  1088                 scan(tree.extending);

  1089                 scan(tree.implementing);

  1090             }

  1091             scan(tree.defs);

  1092         }

  1093 

  1094         /**

  1095          * Resolve declaration vs. type annotations in methods and

  1096          * then determine the positions.

  1097          */

  1098         @Override

  1099         public void visitMethodDef(final JCMethodDecl tree) {

  1100             if (tree.sym == null) {

  1101                 Assert.error("Visiting tree node before memberEnter");

  1102             }

  1103             if (sigOnly) {

  1104                 if (!tree.mods.annotations.isEmpty()) {

  1105                     if (tree.sym.isConstructor()) {

  1106                         final TypeAnnotationPosition pos =

  1107                             TypeAnnotationPosition.methodReturn(tree.pos);

  1108                         // Use null to mark that the annotations go

  1109                         // with the symbol.

  1110                         separateAnnotationsKinds(tree, null, tree.sym, pos);

  1111                     } else {

  1112                         final TypeAnnotationPosition pos =

  1113                             TypeAnnotationPosition.methodReturn(tree.restype.pos);

  1114                         separateAnnotationsKinds(tree.restype,

  1115                                                  tree.sym.type.getReturnType(),

  1116                                                  tree.sym, pos);

  1117                     }

  1118                 }

  1119                 if (tree.recvparam != null && tree.recvparam.sym != null &&

  1120                         !tree.recvparam.mods.annotations.isEmpty()) {

  1121                     // Nothing to do for separateAnnotationsKinds if

  1122                     // there are no annotations of either kind.

  1123                     // TODO: make sure there are no declaration annotations.

  1124                     final TypeAnnotationPosition pos =

  1125                         TypeAnnotationPosition.methodReceiver(tree.recvparam.vartype.pos);

  1126                     separateAnnotationsKinds(tree.recvparam.vartype,

  1127                                              tree.recvparam.sym.type,

  1128                                              tree.recvparam.sym, pos);

  1129                 }

  1130                 int i = 0;

  1131                 for (JCVariableDecl param : tree.params) {

  1132                     if (!param.mods.annotations.isEmpty()) {

  1133                         // Nothing to do for separateAnnotationsKinds if

  1134                         // there are no annotations of either kind.