1 /*
2 * Copyright (c) 2009, 2022, 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 import javax.tools.JavaFileObject;
32
33 import com.sun.tools.javac.code.Attribute.TypeCompound;
34 import com.sun.tools.javac.code.Symbol.ClassSymbol;
35 import com.sun.tools.javac.code.Symbol.RecordComponent;
36 import com.sun.tools.javac.code.Symbol.TypeSymbol;
37 import com.sun.tools.javac.code.Type.ArrayType;
38 import com.sun.tools.javac.code.Type.CapturedType;
39 import com.sun.tools.javac.code.Type.ClassType;
40 import com.sun.tools.javac.code.Type.ErrorType;
41 import com.sun.tools.javac.code.Type.ForAll;
42 import com.sun.tools.javac.code.Type.MethodType;
43 import com.sun.tools.javac.code.Type.PackageType;
44 import com.sun.tools.javac.code.Type.TypeVar;
45 import com.sun.tools.javac.code.Type.UndetVar;
46 import com.sun.tools.javac.code.Type.Visitor;
47 import com.sun.tools.javac.code.Type.WildcardType;
48 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntry;
49 import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntryKind;
50 import com.sun.tools.javac.code.Symbol.VarSymbol;
51 import com.sun.tools.javac.code.Symbol.MethodSymbol;
52 import com.sun.tools.javac.code.Type.ModuleType;
53 import com.sun.tools.javac.code.TypeMetadata.Entry.Kind;
54 import com.sun.tools.javac.comp.Annotate;
55 import com.sun.tools.javac.comp.Attr;
56 import com.sun.tools.javac.comp.AttrContext;
57 import com.sun.tools.javac.comp.Env;
58 import com.sun.tools.javac.resources.CompilerProperties.Errors;
59 import com.sun.tools.javac.tree.JCTree;
60 import com.sun.tools.javac.tree.JCTree.JCAnnotatedType;
61 import com.sun.tools.javac.tree.JCTree.JCAnnotation;
62 import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
63 import com.sun.tools.javac.tree.JCTree.JCBlock;
64 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
65 import com.sun.tools.javac.tree.JCTree.JCExpression;
66 import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
67 import com.sun.tools.javac.tree.JCTree.JCLambda;
68 import com.sun.tools.javac.tree.JCTree.JCMemberReference;
69 import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
70 import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
71 import com.sun.tools.javac.tree.JCTree.JCNewArray;
72 import com.sun.tools.javac.tree.JCTree.JCNewClass;
73 import com.sun.tools.javac.tree.JCTree.JCTypeApply;
74 import com.sun.tools.javac.tree.JCTree.JCTypeIntersection;
75 import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
76 import com.sun.tools.javac.tree.JCTree.JCTypeUnion;
77 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
78 import com.sun.tools.javac.tree.JCTree.Tag;
79 import com.sun.tools.javac.tree.TreeInfo;
80 import com.sun.tools.javac.tree.TreeScanner;
81 import com.sun.tools.javac.util.Assert;
82 import com.sun.tools.javac.util.Context;
83 import com.sun.tools.javac.util.List;
84 import com.sun.tools.javac.util.ListBuffer;
85 import com.sun.tools.javac.util.Log;
86 import com.sun.tools.javac.util.Names;
87
88 import static com.sun.tools.javac.code.Flags.RECORD;
89 import static com.sun.tools.javac.code.Kinds.Kind.*;
90
91 /**
92 * Contains operations specific to processing type annotations.
93 * This class has two functions:
94 * separate declaration from type annotations and insert the type
95 * annotations to their types;
96 * and determine the TypeAnnotationPositions for all type annotations.
97 */
98 public class TypeAnnotations {
99 protected static final Context.Key<TypeAnnotations> typeAnnosKey = new Context.Key<>();
100
101 public static TypeAnnotations instance(Context context) {
102 TypeAnnotations instance = context.get(typeAnnosKey);
103 if (instance == null)
104 instance = new TypeAnnotations(context);
105 return instance;
106 }
107
108 final Log log;
109 final Names names;
110 final Symtab syms;
111 final Annotate annotate;
112 final Attr attr;
113
114 protected TypeAnnotations(Context context) {
115 context.put(typeAnnosKey, this);
116 names = Names.instance(context);
117 log = Log.instance(context);
118 syms = Symtab.instance(context);
119 annotate = Annotate.instance(context);
120 attr = Attr.instance(context);
121 }
122
123 /**
124 * Separate type annotations from declaration annotations and
125 * determine the correct positions for type annotations.
126 * This version only visits types in signatures and should be
127 * called from MemberEnter.
128 */
129 public void organizeTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {
130 annotate.afterTypes(() -> {
131 JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);
132 try {
133 new TypeAnnotationPositions(true).scan(tree);
134 } finally {
135 log.useSource(oldSource);
136 }
137 });
138 }
139
140 public void validateTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {
141 annotate.validate(() -> { //validate annotations
142 JavaFileObject oldSource = log.useSource(env.toplevel.sourcefile);
143 try {
144 attr.validateTypeAnnotations(tree, true);
145 } finally {
146 log.useSource(oldSource);
147 }
148 });
149 }
150
151 /**
152 * This version only visits types in bodies, that is, field initializers,
153 * top-level blocks, and method bodies, and should be called from Attr.
154 */
155 public void organizeTypeAnnotationsBodies(JCClassDecl tree) {
156 new TypeAnnotationPositions(false).scan(tree);
157 }
158
159 public enum AnnotationType { DECLARATION, TYPE, NONE, BOTH }
160
161 public List<Attribute> annotationTargets(TypeSymbol tsym) {
162 Attribute.Compound atTarget = tsym.getAnnotationTypeMetadata().getTarget();
163 if (atTarget == null) {
164 return null;
165 }
166
167 Attribute atValue = atTarget.member(names.value);
168 if (!(atValue instanceof Attribute.Array arrayVal)) {
169 return null;
170 }
171
172 List<Attribute> targets = arrayVal.getValue();
173 if (targets.stream().anyMatch(a -> !(a instanceof Attribute.Enum))) {
174 return null;
175 }
176
177 return targets;
178 }
179
180 /**
181 * Determine whether an annotation is a declaration annotation,
182 * a type annotation, or both (or none, i.e a non-annotation masquerading as one).
183 */
184 public AnnotationType annotationTargetType(Attribute.Compound a, Symbol s) {
185 if (!a.type.tsym.isAnnotationType()) {
186 return AnnotationType.NONE;
187 }
188 List<Attribute> targets = annotationTargets(a.type.tsym);
189 return (targets == null) ?
190 AnnotationType.DECLARATION :
191 targets.stream()
192 .map(attr -> targetToAnnotationType(attr, s))
193 .reduce(AnnotationType.NONE, this::combineAnnotationType);
194 }
195
196 private AnnotationType combineAnnotationType(AnnotationType at1, AnnotationType at2) {
197 if (at1 == AnnotationType.NONE) {
198 return at2;
199 } else if (at2 == AnnotationType.NONE) {
200 return at1;
201 } else if (at1 != at2) {
202 return AnnotationType.BOTH;
203 } else {
204 return at1;
205 }
206 }
207
208 private AnnotationType targetToAnnotationType(Attribute a, Symbol s) {
209 Attribute.Enum e = (Attribute.Enum)a;
210 if (e.value.name == names.TYPE) {
211 if (s.kind == TYP)
212 return AnnotationType.DECLARATION;
213 } else if (e.value.name == names.FIELD || e.value.name == names.RECORD_COMPONENT) {
214 if (s.kind == VAR &&
215 s.owner.kind != MTH)
216 return AnnotationType.DECLARATION;
217 } else if (e.value.name == names.METHOD) {
218 if (s.kind == MTH &&
219 !s.isInitOrVNew())
220 return AnnotationType.DECLARATION;
221 } else if (e.value.name == names.PARAMETER) {
222 if (s.kind == VAR &&
223 s.owner.kind == MTH &&
224 (s.flags() & Flags.PARAMETER) != 0)
225 return AnnotationType.DECLARATION;
226 } else if (e.value.name == names.CONSTRUCTOR) {
227 if (s.kind == MTH &&
228 s.isConstructor())
229 return AnnotationType.DECLARATION;
230 } else if (e.value.name == names.LOCAL_VARIABLE) {
231 if (s.kind == VAR &&
232 s.owner.kind == MTH &&
233 (s.flags() & Flags.PARAMETER) == 0)
234 return AnnotationType.DECLARATION;
235 } else if (e.value.name == names.ANNOTATION_TYPE) {
236 if (s.kind == TYP &&
237 (s.flags() & Flags.ANNOTATION) != 0)
238 return AnnotationType.DECLARATION;
239 } else if (e.value.name == names.PACKAGE) {
240 if (s.kind == PCK)
241 return AnnotationType.DECLARATION;
242 } else if (e.value.name == names.TYPE_USE) {
243 if (s.kind == TYP ||
244 s.kind == VAR ||
245 (s.kind == MTH && !s.isInitOrVNew() &&
246 !s.type.getReturnType().hasTag(TypeTag.VOID)) ||
247 (s.kind == MTH && s.isInitOrVNew()))
248 return AnnotationType.TYPE;
249 } else if (e.value.name == names.TYPE_PARAMETER) {
250 /* Irrelevant in this case */
251 // TYPE_PARAMETER doesn't aid in distinguishing between
252 // Type annotations and declaration annotations on an
253 // Element
254 } else if (e.value.name == names.MODULE) {
255 if (s.kind == MDL)
256 return AnnotationType.DECLARATION;
257 } else {
258 Assert.error("annotationTargetType(): unrecognized Attribute name " + e.value.name +
259 " (" + e.value.name.getClass() + ")");
260 return AnnotationType.DECLARATION;
261 }
262 return AnnotationType.NONE;
263 }
264
265 private class TypeAnnotationPositions extends TreeScanner {
266
267 private final boolean sigOnly;
268
269 TypeAnnotationPositions(boolean sigOnly) {
270 this.sigOnly = sigOnly;
271 }
272
273 /*
274 * When traversing the AST we keep the "frames" of visited
275 * trees in order to determine the position of annotations.
276 */
277 private List<JCTree> frames = List.nil();
278
279 protected void push(JCTree t) {
280 frames = frames.prepend(t);
281 }
282 protected JCTree pop() {
283 JCTree t = frames.head;
284 frames = frames.tail;
285 return t;
286 }
287 // could this be frames.elems.tail.head?
288 private JCTree peek2() {
289 return frames.tail.head;
290 }
291
292 @Override
293 public void scan(JCTree tree) {
294 push(tree);
295 try {
296 super.scan(tree);
297 } finally {
298 pop();
299 }
300 }
301
302 /**
303 * Separates type annotations from declaration annotations.
304 * This step is needed because in certain locations (where declaration
305 * and type annotations can be mixed, e.g. the type of a field)
306 * we never build an JCAnnotatedType. This step finds these
307 * annotations and marks them as if they were part of the type.
308 */
309 private void separateAnnotationsKinds(JCTree typetree, Type type,
310 Symbol sym, TypeAnnotationPosition pos)
311 {
312 List<Attribute.Compound> allAnnotations = sym.getRawAttributes();
313 ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<>();
314 ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<>();
315 ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<>();
316
317 for (Attribute.Compound a : allAnnotations) {
318 switch (annotationTargetType(a, sym)) {
319 case DECLARATION:
320 declAnnos.append(a);
321 break;
322 case BOTH: {
323 declAnnos.append(a);
324 Attribute.TypeCompound ta = toTypeCompound(a, pos);
325 typeAnnos.append(ta);
326 break;
327 }
328 case TYPE: {
329 Attribute.TypeCompound ta = toTypeCompound(a, pos);
330 typeAnnos.append(ta);
331 // Also keep track which annotations are only type annotations
332 onlyTypeAnnos.append(ta);
333 break;
334 }
335 case NONE: // Error signaled already, just drop the non-annotation.
336 break;
337 }
338 }
339
340 // If we have no type annotations we are done for this Symbol
341 if (typeAnnos.isEmpty()) {
342 return;
343 }
344
345 // Reset decl annotations to the set {all - type only}
346 sym.resetAnnotations();
347 sym.setDeclarationAttributes(declAnnos.toList());
348
349 List<Attribute.TypeCompound> typeAnnotations = typeAnnos.toList();
350
351 if (type == null) {
352 // When type is null, put the type annotations to the symbol.
353 // This is used for constructor return annotations, for which
354 // we use the type of the enclosing class.
355 type = sym.getEnclosingElement().asType();
356
357 // Declaration annotations are always allowed on constructor returns.
358 // Therefore, use typeAnnotations instead of onlyTypeAnnos.
359 typeWithAnnotations(typetree, type, typeAnnotations, typeAnnotations, pos);
360 // Note that we don't use the result, the call to
361 // typeWithAnnotations side-effects the type annotation positions.
362 // This is important for constructors of nested classes.
363 sym.appendUniqueTypeAttributes(typeAnnotations);
364 return;
365 }
366
367 // type is non-null, add type annotations from declaration context to the type
368 type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList(), pos);
369
370 if (sym.getKind() == ElementKind.METHOD) {
371 sym.type.asMethodType().restype = type;
372 } else if (sym.getKind() == ElementKind.PARAMETER && currentLambda == null) {
373 sym.type = type;
374 if (sym.getQualifiedName().equals(names._this)) {
375 sym.owner.type.asMethodType().recvtype = type;
376 // note that the typeAnnotations will also be added to the owner below.
377 } else {
378 MethodType methType = sym.owner.type.asMethodType();
379 List<VarSymbol> params = ((MethodSymbol)sym.owner).params;
380 List<Type> oldArgs = methType.argtypes;
381 ListBuffer<Type> newArgs = new ListBuffer<>();
382 while (params.nonEmpty()) {
383 if (params.head == sym) {
384 newArgs.add(type);
385 } else {
386 newArgs.add(oldArgs.head);
387 }
388 oldArgs = oldArgs.tail;
389 params = params.tail;
390 }
391 methType.argtypes = newArgs.toList();
392 }
393 } else {
394 sym.type = type;
395 }
396
397 sym.appendUniqueTypeAttributes(typeAnnotations);
398
399 if (sym.getKind() == ElementKind.PARAMETER ||
400 sym.getKind() == ElementKind.LOCAL_VARIABLE ||
401 sym.getKind() == ElementKind.RESOURCE_VARIABLE ||
402 sym.getKind() == ElementKind.EXCEPTION_PARAMETER ||
403 sym.getKind() == ElementKind.BINDING_VARIABLE) {
404 appendTypeAnnotationsToOwner(sym, typeAnnotations);
405 }
406 }
407
408 private void appendTypeAnnotationsToOwner(Symbol sym, List<Attribute.TypeCompound> typeAnnotations) {
409 // Make sure all type annotations from the symbol are also
410 // on the owner. If the owner is an initializer block, propagate
411 // to the type.
412 final long ownerFlags = sym.owner.flags();
413 if ((ownerFlags & Flags.BLOCK) != 0) {
414 // Store init and clinit type annotations with the ClassSymbol
415 // to allow output in Gen.normalizeDefs.
416 ClassSymbol cs = (ClassSymbol) sym.owner.owner;
417 if ((ownerFlags & Flags.STATIC) != 0) {
418 cs.appendClassInitTypeAttributes(typeAnnotations);
419 } else {
420 cs.appendInitTypeAttributes(typeAnnotations);
421 }
422 } else {
423 sym.owner.appendUniqueTypeAttributes(typeAnnotations);
424 }
425 }
426
427 // This method has a similar purpose as
428 // {@link com.sun.tools.javac.parser.JavacParser.insertAnnotationsToMostInner(JCExpression, List<JCTypeAnnotation>, boolean)}
429 // We found a type annotation in a declaration annotation position,
430 // for example, on the return type.
431 // Such an annotation is _not_ part of an JCAnnotatedType tree and we therefore
432 // need to set its position explicitly.
433 // The method returns a copy of type that contains these annotations.
434 //
435 // As a side effect the method sets the type annotation position of "annotations".
436 // Note that it is assumed that all annotations share the same position.
437 private Type typeWithAnnotations(final JCTree typetree, final Type type,
438 final List<Attribute.TypeCompound> annotations,
439 final List<Attribute.TypeCompound> onlyTypeAnnotations,
440 final TypeAnnotationPosition pos)
441 {
442 if (annotations.isEmpty()) {
443 return type;
444 }
445 // All annotations share the same position
446 for (TypeCompound tc : annotations) {
447 Assert.check(tc.position == pos);
448 }
449
450 if (type.hasTag(TypeTag.ARRAY))
451 return rewriteArrayType((ArrayType)type, annotations, pos);
452
453 if (type.hasTag(TypeTag.TYPEVAR)) {
454 return type.annotatedType(onlyTypeAnnotations);
455 } else if (type.getKind() == TypeKind.UNION) {
456 // There is a TypeKind, but no TypeTag.
457 JCTypeUnion tutree = (JCTypeUnion)typetree;
458 JCExpression fst = tutree.alternatives.get(0);
459 Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations, pos);
460 fst.type = res;
461 // TODO: do we want to set res as first element in uct.alternatives?
462 // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;
463 // Return the un-annotated union-type.
464 return type;
465 } else {
466 Type enclTy = type;
467 Element enclEl = type.asElement();
468 JCTree enclTr = typetree;
469
470 while (enclEl != null &&
471 enclEl.getKind() != ElementKind.PACKAGE &&
472 enclTy != null &&
473 enclTy.getKind() != TypeKind.NONE &&
474 enclTy.getKind() != TypeKind.ERROR &&
475 (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT ||
476 enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE ||
477 enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) {
478 // Iterate also over the type tree, not just the type: the type is already
479 // completely resolved and we cannot distinguish where the annotation
480 // belongs for a nested type.
481 if (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT) {
482 // only change encl in this case.
483 enclTy = enclTy.getEnclosingType();
484 enclEl = enclEl.getEnclosingElement();
485 enclTr = ((JCFieldAccess)enclTr).getExpression();
486 } else if (enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE) {
487 enclTr = ((JCTypeApply)enclTr).getType();
488 } else {
489 // only other option because of while condition
490 enclTr = ((JCAnnotatedType)enclTr).getUnderlyingType();
491 }
492 }
493
494 /** We are trying to annotate some enclosing type,
495 * but nothing more exists.
496 */
497 if (enclTy != null &&
498 enclTy.hasTag(TypeTag.NONE)) {
499 switch (onlyTypeAnnotations.size()) {
500 case 0:
501 // Don't issue an error if all type annotations are
502 // also declaration annotations.
503 // If the annotations are also declaration annotations, they are
504 // illegal as type annotations but might be legal as declaration annotations.
505 // The normal declaration annotation checks make sure that the use is valid.
506 break;
507 case 1:
508 log.error(typetree.pos(),
509 Errors.CantTypeAnnotateScoping1(onlyTypeAnnotations.head));
510 break;
511 default:
512 log.error(typetree.pos(),
513 Errors.CantTypeAnnotateScoping(onlyTypeAnnotations));
514 }
515 return type;
516 }
517
518 // At this point we have visited the part of the nested
519 // type that is written in the source code.
520 // Now count from here to the actual top-level class to determine
521 // the correct nesting.
522
523 // The genericLocation for the annotation.
524 ListBuffer<TypePathEntry> depth = new ListBuffer<>();
525
526 Type topTy = enclTy;
527 while (enclEl != null &&
528 enclEl.getKind() != ElementKind.PACKAGE &&
529 topTy != null &&
530 topTy.getKind() != TypeKind.NONE &&
531 topTy.getKind() != TypeKind.ERROR) {
532 topTy = topTy.getEnclosingType();
533 enclEl = enclEl.getEnclosingElement();
534
535 if (topTy != null && topTy.getKind() != TypeKind.NONE) {
536 // Only count enclosing types.
537 depth = depth.append(TypePathEntry.INNER_TYPE);
538 }
539 }
540
541 if (depth.nonEmpty()) {
542 // Only need to change the annotation positions
543 // if they are on an enclosed type.
544 pos.location = pos.location.appendList(depth.toList());
545 }
546
547 Type ret = typeWithAnnotations(type, enclTy, annotations);
548 typetree.type = ret;
549 return ret;
550 }
551 }
552
553 /**
554 * Create a copy of the {@code Type type} with the help of the Tree for a type
555 * {@code JCTree typetree} inserting all type annotations in {@code annotations} to the
556 * innermost array component type.
557 *
558 * SIDE EFFECT: Update position for the annotations to be {@code pos}.
559 */
560 private Type rewriteArrayType(ArrayType type, List<TypeCompound> annotations, TypeAnnotationPosition pos) {
561 ArrayType tomodify = new ArrayType(type);
562 if (type.isVarargs()) {
563 tomodify = tomodify.makeVarargs();
564 }
565 ArrayType res = tomodify;
566
567 List<TypePathEntry> loc = List.nil();
568
569 // peel one and update loc
570 Type tmpType = type.elemtype;
571 loc = loc.prepend(TypePathEntry.ARRAY);
572
573 while (tmpType.hasTag(TypeTag.ARRAY)) {
574 ArrayType arr = (ArrayType)tmpType;
575
576 // Update last type with new element type
577 ArrayType tmp = new ArrayType(arr);
578 tomodify.elemtype = tmp;
579 tomodify = tmp;
580
581 tmpType = arr.elemtype;
582 loc = loc.prepend(TypePathEntry.ARRAY);
583 }
584
585 // Fix innermost element type
586 Type elemType;
587 if (tmpType.getMetadata() != null) {
588 List<TypeCompound> tcs;
589 if (tmpType.getAnnotationMirrors().isEmpty()) {
590 tcs = annotations;
591 } else {
592 // Special case, lets prepend
593 tcs = annotations.appendList(tmpType.getAnnotationMirrors());
594 }
595 elemType = tmpType.cloneWithMetadata(tmpType
596 .getMetadata()
597 .without(Kind.ANNOTATIONS)
598 .combine(new TypeMetadata.Annotations(tcs)));
599 } else {
600 elemType = tmpType.cloneWithMetadata(new TypeMetadata(new TypeMetadata.Annotations(annotations)));
601 }
602 tomodify.elemtype = elemType;
603
604 // Update positions
605 pos.location = loc;
606
607 return res;
608 }
609
610 /** Return a copy of the first type that only differs by
611 * inserting the annotations to the left-most/inner-most type
612 * or the type given by stopAt.
613 *
614 * We need the stopAt parameter to know where on a type to
615 * put the annotations.
616 * If we have nested classes Outer > Middle > Inner, and we
617 * have the source type "@A Middle.Inner", we will invoke
618 * this method with type = Outer.Middle.Inner,
619 * stopAt = Middle.Inner, and annotations = @A.
620 *
621 * @param type The type to copy.
622 * @param stopAt The type to stop at.
623 * @param annotations The annotations to insert.
624 * @return A copy of type that contains the annotations.
625 */
626 private Type typeWithAnnotations(final Type type,
627 final Type stopAt,
628 final List<Attribute.TypeCompound> annotations) {
629 Visitor<Type, List<TypeCompound>> visitor =
630 new Type.Visitor<Type, List<Attribute.TypeCompound>>() {
631 @Override
632 public Type visitClassType(ClassType t, List<TypeCompound> s) {
633 // assert that t.constValue() == null?
634 if (t == stopAt ||
635 t.getEnclosingType() == Type.noType) {
636 return t.annotatedType(s);
637 } else {
638 ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),
639 t.typarams_field, t.tsym,
640 t.getMetadata(), t.getFlavor());
641 ret.all_interfaces_field = t.all_interfaces_field;
642 ret.allparams_field = t.allparams_field;
643 ret.interfaces_field = t.interfaces_field;
644 ret.rank_field = t.rank_field;
645 ret.supertype_field = t.supertype_field;
646 return ret;
647 }
648 }
649
650 @Override
651 public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {
652 return t.annotatedType(s);
653 }
654
655 @Override
656 public Type visitArrayType(ArrayType t, List<TypeCompound> s) {
657 ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym,
658 t.getMetadata());
659 return ret;
660 }
661
662 @Override
663 public Type visitMethodType(MethodType t, List<TypeCompound> s) {
664 // Impossible?
665 return t;
666 }
667
668 @Override
669 public Type visitPackageType(PackageType t, List<TypeCompound> s) {
670 // Impossible?
671 return t;
672 }
673
674 @Override
675 public Type visitTypeVar(TypeVar t, List<TypeCompound> s) {
676 return t.annotatedType(s);
677 }
678
679 @Override
680 public Type visitModuleType(ModuleType t, List<TypeCompound> s) {
681 return t.annotatedType(s);
682 }
683
684 @Override
685 public Type visitCapturedType(CapturedType t, List<TypeCompound> s) {
686 return t.annotatedType(s);
687 }
688
689 @Override
690 public Type visitForAll(ForAll t, List<TypeCompound> s) {
691 // Impossible?
692 return t;
693 }
694
695 @Override
696 public Type visitUndetVar(UndetVar t, List<TypeCompound> s) {
697 // Impossible?
698 return t;
699 }
700
701 @Override
702 public Type visitErrorType(ErrorType t, List<TypeCompound> s) {
703 return t.annotatedType(s);
704 }
705
706 @Override
707 public Type visitType(Type t, List<TypeCompound> s) {
708 return t.annotatedType(s);
709 }
710 };
711
712 return type.accept(visitor, annotations);
713 }
714
715 private Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) {
716 // It is safe to alias the position.
717 return new Attribute.TypeCompound(a, p);
718 }
719
720
721 /* This is the beginning of the second part of organizing
722 * type annotations: determine the type annotation positions.
723 */
724 private TypeAnnotationPosition
725 resolveFrame(JCTree tree,
726 JCTree frame,
727 List<JCTree> path,
728 JCLambda currentLambda,
729 int outer_type_index,
730 ListBuffer<TypePathEntry> location)
731 {
732
733 // Note that p.offset is set in
734 // com.sun.tools.javac.jvm.Gen.setTypeAnnotationPositions(int)
735
736 switch (frame.getKind()) {
737 case TYPE_CAST:
738 return TypeAnnotationPosition.typeCast(location.toList(),
739 currentLambda,
740 outer_type_index,
741 frame.pos);
742
743 case INSTANCE_OF:
744 return TypeAnnotationPosition.instanceOf(location.toList(),
745 currentLambda,
746 frame.pos);
747
748 case NEW_CLASS:
749 final JCNewClass frameNewClass = (JCNewClass) frame;
750 if (frameNewClass.def != null) {
751 // Special handling for anonymous class instantiations
752 final JCClassDecl frameClassDecl = frameNewClass.def;
753 if (frameClassDecl.implementing.contains(tree)) {
754 final int type_index =
755 frameClassDecl.implementing.indexOf(tree);
756 return TypeAnnotationPosition
757 .classExtends(location.toList(), currentLambda,
758 type_index, frame.pos);
759 } else {
760 //for encl.new @TA Clazz(), tree may be different from frameClassDecl.extending
761 return TypeAnnotationPosition
762 .classExtends(location.toList(), currentLambda,
763 frame.pos);
764 }
765 } else if (frameNewClass.typeargs.contains(tree)) {
766 final int type_index =
767 frameNewClass.typeargs.indexOf(tree);
768 return TypeAnnotationPosition
769 .constructorInvocationTypeArg(location.toList(),
770 currentLambda,
771 type_index,
772 frame.pos);
773 } else {
774 return TypeAnnotationPosition
775 .newObj(location.toList(), currentLambda,
776 frame.pos);
777 }
778
779 case NEW_ARRAY:
780 return TypeAnnotationPosition
781 .newObj(location.toList(), currentLambda, frame.pos);
782
783 case ANNOTATION_TYPE:
784 case CLASS:
785 case ENUM:
786 case INTERFACE:
787 case RECORD:
788 if (((JCClassDecl)frame).extending == tree) {
789 return TypeAnnotationPosition
790 .classExtends(location.toList(), currentLambda,
791 frame.pos);
792 } else if (((JCClassDecl)frame).implementing.contains(tree)) {
793 final int type_index =
794 ((JCClassDecl)frame).implementing.indexOf(tree);
795 return TypeAnnotationPosition
796 .classExtends(location.toList(), currentLambda,
797 type_index, frame.pos);
798 } else if (((JCClassDecl)frame).typarams.contains(tree)) {
799 final int parameter_index =
800 ((JCClassDecl)frame).typarams.indexOf(tree);
801 return TypeAnnotationPosition
802 .typeParameter(location.toList(), currentLambda,
803 parameter_index, frame.pos);
804 } else {
805 throw new AssertionError("Could not determine position of tree " +
806 tree + " within frame " + frame);
807 }
808
809 case METHOD: {
810 final JCMethodDecl frameMethod = (JCMethodDecl) frame;
811 if (frameMethod.thrown.contains(tree)) {
812 final int type_index = frameMethod.thrown.indexOf(tree);
813 return TypeAnnotationPosition
814 .methodThrows(location.toList(), currentLambda,
815 type_index, frame.pos);
816 } else if (frameMethod.restype == tree) {
817 return TypeAnnotationPosition
818 .methodReturn(location.toList(), currentLambda,
819 frame.pos);
820 } else if (frameMethod.typarams.contains(tree)) {
821 final int parameter_index =
822 frameMethod.typarams.indexOf(tree);
823 return TypeAnnotationPosition
824 .methodTypeParameter(location.toList(),
825 currentLambda,
826 parameter_index, frame.pos);
827 } else {
828 throw new AssertionError("Could not determine position of tree " + tree +
829 " within frame " + frame);
830 }
831 }
832
833 case PARAMETERIZED_TYPE: {
834 List<JCTree> newPath = path.tail;
835
836 if (((JCTypeApply)frame).clazz == tree) {
837 // generic: RAW; noop
838 } else if (((JCTypeApply)frame).arguments.contains(tree)) {
839 JCTypeApply taframe = (JCTypeApply) frame;
840 int arg = taframe.arguments.indexOf(tree);
841 location = location.prepend(
842 new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT,
843 arg));
844
845 Type typeToUse;
846 if (newPath.tail != null &&
847 newPath.tail.head.hasTag(Tag.NEWCLASS)) {
848 // If we are within an anonymous class
849 // instantiation, use its type, because it
850 // contains a correctly nested type.
851 typeToUse = newPath.tail.head.type;
852 } else {
853 typeToUse = taframe.type;
854 }
855
856 location = locateNestedTypes(typeToUse, location);
857 } else {
858 throw new AssertionError("Could not determine type argument position of tree " + tree +
859 " within frame " + frame);
860 }
861
862 return resolveFrame(newPath.head, newPath.tail.head,
863 newPath, currentLambda,
864 outer_type_index, location);
865 }
866
867 case MEMBER_REFERENCE: {
868 JCMemberReference mrframe = (JCMemberReference) frame;
869
870 if (mrframe.expr == tree) {
871 switch (mrframe.mode) {
872 case INVOKE:
873 return TypeAnnotationPosition
874 .methodRef(location.toList(), currentLambda,
875 frame.pos);
876 case NEW:
877 return TypeAnnotationPosition
878 .constructorRef(location.toList(),
879 currentLambda,
880 frame.pos);
881 default:
882 throw new AssertionError("Unknown method reference mode " + mrframe.mode +
883 " for tree " + tree + " within frame " + frame);
884 }
885 } else if (mrframe.typeargs != null &&
886 mrframe.typeargs.contains(tree)) {
887 final int type_index = mrframe.typeargs.indexOf(tree);
888 switch (mrframe.mode) {
889 case INVOKE:
890 return TypeAnnotationPosition
891 .methodRefTypeArg(location.toList(),
892 currentLambda,
893 type_index, frame.pos);
894 case NEW:
895 return TypeAnnotationPosition
896 .constructorRefTypeArg(location.toList(),
897 currentLambda,
898 type_index, frame.pos);
899 default:
900 throw new AssertionError("Unknown method reference mode " + mrframe.mode +
901 " for tree " + tree + " within frame " + frame);
902 }
903 } else {
904 throw new AssertionError("Could not determine type argument position of tree " + tree +
905 " within frame " + frame);
906 }
907 }
908
909 case ARRAY_TYPE: {
910 location = location.prepend(TypePathEntry.ARRAY);
911 List<JCTree> newPath = path.tail;
912 while (true) {
913 JCTree npHead = newPath.tail.head;
914 if (npHead.hasTag(JCTree.Tag.TYPEARRAY)) {
915 newPath = newPath.tail;
916 location = location.prepend(TypePathEntry.ARRAY);
917 } else if (npHead.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
918 newPath = newPath.tail;
919 } else {
920 break;
921 }
922 }
923 return resolveFrame(newPath.head, newPath.tail.head,
924 newPath, currentLambda,
925 outer_type_index, location);
926 }
927
928 case TYPE_PARAMETER:
929 if (path.tail.tail.head.hasTag(JCTree.Tag.CLASSDEF)) {
930 final JCClassDecl clazz =
931 (JCClassDecl)path.tail.tail.head;
932 final int parameter_index =
933 clazz.typarams.indexOf(path.tail.head);
934 final int bound_index =
935 ((JCTypeParameter)frame).bounds.get(0)
936 .type.isInterface() ?
937 ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:
938 ((JCTypeParameter)frame).bounds.indexOf(tree);
939 return TypeAnnotationPosition
940 .typeParameterBound(location.toList(),
941 currentLambda,
942 parameter_index, bound_index,
943 frame.pos);
944 } else if (path.tail.tail.head.hasTag(JCTree.Tag.METHODDEF)) {
945 final JCMethodDecl method =
946 (JCMethodDecl)path.tail.tail.head;
947 final int parameter_index =
948 method.typarams.indexOf(path.tail.head);
949 final int bound_index =
950 ((JCTypeParameter)frame).bounds.get(0)
951 .type.isInterface() ?
952 ((JCTypeParameter)frame).bounds.indexOf(tree) + 1:
953 ((JCTypeParameter)frame).bounds.indexOf(tree);
954 return TypeAnnotationPosition
955 .methodTypeParameterBound(location.toList(),
956 currentLambda,
957 parameter_index,
958 bound_index,
959 frame.pos);
960 } else {
961 throw new AssertionError("Could not determine position of tree " + tree +
962 " within frame " + frame);
963 }
964
965 case VARIABLE:
966 VarSymbol v = ((JCVariableDecl) frame).sym;
967 if (v.getKind() != ElementKind.FIELD) {
968 appendTypeAnnotationsToOwner(v, v.getRawTypeAttributes());
969 }
970 switch (v.getKind()) {
971 case BINDING_VARIABLE:
972 case LOCAL_VARIABLE:
973 return TypeAnnotationPosition
974 .localVariable(location.toList(), currentLambda,
975 frame.pos);
976 case FIELD:
977 return TypeAnnotationPosition.field(location.toList(),
978 currentLambda,
979 frame.pos);
980 case PARAMETER:
981 if (v.getQualifiedName().equals(names._this)) {
982 return TypeAnnotationPosition
983 .methodReceiver(location.toList(),
984 currentLambda,
985 frame.pos);
986 } else {
987 final int parameter_index =
988 methodParamIndex(path, frame);
989 return TypeAnnotationPosition
990 .methodParameter(location.toList(),
991 currentLambda,
992 parameter_index,
993 frame.pos);
994 }
995 case EXCEPTION_PARAMETER:
996 return TypeAnnotationPosition
997 .exceptionParameter(location.toList(),
998 currentLambda,
999 frame.pos);
1000 case RESOURCE_VARIABLE:
1001 return TypeAnnotationPosition
1002 .resourceVariable(location.toList(),
1003 currentLambda,
1004 frame.pos);
1005 default:
1006 throw new AssertionError("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
1007 }
1008
1009 case ANNOTATED_TYPE: {
1010 if (frame == tree) {
1011 // This is only true for the first annotated type we see.
1012 // For any other annotated types along the path, we do
1013 // not care about inner types.
1014 JCAnnotatedType atypetree = (JCAnnotatedType) frame;
1015 final Type utype = atypetree.underlyingType.type;
1016 Assert.checkNonNull(utype);
1017 Symbol tsym = utype.tsym;
1018 if (tsym.getKind().equals(ElementKind.TYPE_PARAMETER) ||
1019 utype.getKind().equals(TypeKind.WILDCARD) ||
1020 utype.getKind().equals(TypeKind.ARRAY)) {
1021 // Type parameters, wildcards, and arrays have the declaring
1022 // class/method as enclosing elements.
1023 // There is actually nothing to do for them.
1024 } else {
1025 location = locateNestedTypes(utype, location);
1026 }
1027 }
1028 List<JCTree> newPath = path.tail;
1029 return resolveFrame(newPath.head, newPath.tail.head,
1030 newPath, currentLambda,
1031 outer_type_index, location);
1032 }
1033
1034 case UNION_TYPE: {
1035 List<JCTree> newPath = path.tail;
1036 return resolveFrame(newPath.head, newPath.tail.head,
1037 newPath, currentLambda,
1038 outer_type_index, location);
1039 }
1040
1041 case INTERSECTION_TYPE: {
1042 JCTypeIntersection isect = (JCTypeIntersection)frame;
1043 final List<JCTree> newPath = path.tail;
1044 return resolveFrame(newPath.head, newPath.tail.head,
1045 newPath, currentLambda,
1046 isect.bounds.indexOf(tree), location);
1047 }
1048
1049 case METHOD_INVOCATION: {
1050 JCMethodInvocation invocation = (JCMethodInvocation)frame;
1051 if (!invocation.typeargs.contains(tree)) {
1052 return TypeAnnotationPosition.unknown;
1053 }
1054 MethodSymbol exsym = (MethodSymbol) TreeInfo.symbol(invocation.getMethodSelect());
1055 final int type_index = invocation.typeargs.indexOf(tree);
1056 if (exsym == null) {
1057 throw new AssertionError("could not determine symbol for {" + invocation + "}");
1058 } else if (exsym.isInitOrVNew()) {
1059 return TypeAnnotationPosition
1060 .constructorInvocationTypeArg(location.toList(),
1061 currentLambda,
1062 type_index,
1063 invocation.pos);
1064 } else {
1065 return TypeAnnotationPosition
1066 .methodInvocationTypeArg(location.toList(),
1067 currentLambda,
1068 type_index,
1069 invocation.pos);
1070 }
1071 }
1072
1073 case EXTENDS_WILDCARD:
1074 case SUPER_WILDCARD: {
1075 // Annotations in wildcard bounds
1076 final List<JCTree> newPath = path.tail;
1077 return resolveFrame(newPath.head, newPath.tail.head,
1078 newPath, currentLambda,
1079 outer_type_index,
1080 location.prepend(TypePathEntry.WILDCARD));
1081 }
1082
1083 case MEMBER_SELECT: {
1084 final List<JCTree> newPath = path.tail;
1085 return resolveFrame(newPath.head, newPath.tail.head,
1086 newPath, currentLambda,
1087 outer_type_index, location);
1088 }
1089 case DECONSTRUCTION_PATTERN: {
1090 // TODO: Treat case labels as full type contexts for complete type annotation support in Record Patterns
1091 // https://bugs.openjdk.org/browse/JDK-8298154
1092 return TypeAnnotationPosition.unknown;
1093 }
1094 default:
1095 throw new AssertionError("Unresolved frame: " + frame +
1096 " of kind: " + frame.getKind() +
1097 "\n Looking for tree: " + tree);
1098 }
1099 }
1100
1101 private ListBuffer<TypePathEntry>
1102 locateNestedTypes(Type type,
1103 ListBuffer<TypePathEntry> depth) {
1104 Type encl = type.getEnclosingType();
1105 while (encl != null &&
1106 encl.getKind() != TypeKind.NONE &&
1107 encl.getKind() != TypeKind.ERROR) {
1108 depth = depth.prepend(TypePathEntry.INNER_TYPE);
1109 encl = encl.getEnclosingType();
1110 }
1111 return depth;
1112 }
1113
1114 private int methodParamIndex(List<JCTree> path, JCTree param) {
1115 List<JCTree> curr = path;
1116 while (curr.head.getTag() != Tag.METHODDEF &&
1117 curr.head.getTag() != Tag.LAMBDA) {
1118 curr = curr.tail;
1119 }
1120 if (curr.head.getTag() == Tag.METHODDEF) {
1121 JCMethodDecl method = (JCMethodDecl)curr.head;
1122 return method.params.indexOf(param);
1123 } else if (curr.head.getTag() == Tag.LAMBDA) {
1124 JCLambda lambda = (JCLambda)curr.head;
1125 return lambda.params.indexOf(param);
1126 } else {
1127 Assert.error("methodParamIndex expected to find method or lambda for param: " + param);
1128 return -1;
1129 }
1130 }
1131
1132 // Each class (including enclosed inner classes) is visited separately.
1133 // This flag is used to prevent from visiting inner classes.
1134 private boolean isInClass = false;
1135
1136 @Override
1137 public void visitClassDef(JCClassDecl tree) {
1138 if (isInClass)
1139 return;
1140 isInClass = true;
1141
1142 if (sigOnly) {
1143 scan(tree.mods);
1144 scan(tree.typarams);
1145 scan(tree.extending);
1146 scan(tree.implementing);
1147 }
1148 scan(tree.defs);
1149 if (tree.sym.isRecord()) {
1150 tree.sym.getRecordComponents().forEach(rc -> scan(rc.accessorMeth));
1151 }
1152 }
1153
1154 /**
1155 * Resolve declaration vs. type annotations in methods and
1156 * then determine the positions.
1157 */
1158 @Override
1159 public void visitMethodDef(final JCMethodDecl tree) {
1160 if (tree.sym == null) {
1161 Assert.error("Visiting tree node before memberEnter");
1162 }
1163 if (sigOnly) {
1164 if (!tree.mods.annotations.isEmpty()) {
1165 if (tree.sym.isInitOrVNew()) {
1166 final TypeAnnotationPosition pos =
1167 TypeAnnotationPosition.methodReturn(tree.pos);
1168 // Use null to mark that the annotations go
1169 // with the symbol.
1170 separateAnnotationsKinds(tree, null, tree.sym, pos);
1171 } else {
1172 final TypeAnnotationPosition pos =
1173 TypeAnnotationPosition.methodReturn(tree.restype.pos);
1174 separateAnnotationsKinds(tree.restype,
1175 tree.sym.type.getReturnType(),
1176 tree.sym, pos);
1177 }
1178 }
1179 if (tree.recvparam != null && tree.recvparam.sym != null &&
1180 !tree.recvparam.mods.annotations.isEmpty()) {
1181 // Nothing to do for separateAnnotationsKinds if
1182 // there are no annotations of either kind.
1183 // TODO: make sure there are no declaration annotations.
1184 final TypeAnnotationPosition pos = TypeAnnotationPosition.methodReceiver(tree.recvparam.vartype.pos);
1185 push(tree.recvparam);
1186 try {
1187 separateAnnotationsKinds(tree.recvparam.vartype, tree.recvparam.sym.type, tree.recvparam.sym, pos);
1188 } finally {
1189 pop();
1190 }
1191 }
1192 int i = 0;
1193 for (JCVariableDecl param : tree.params) {
1194 if (!param.mods.annotations.isEmpty()) {
1195 // Nothing to do for separateAnnotationsKinds if
1196 // there are no annotations of either kind.
1197 final TypeAnnotationPosition pos = TypeAnnotationPosition.methodParameter(i, param.vartype.pos);
1198 push(param);
1199 try {
1200 separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
1201 } finally {
1202 pop();
1203 }
1204 }
1205 ++i;
1206 }
1207 }
1208
1209 if (sigOnly) {
1210 scan(tree.mods);
1211 scan(tree.restype);
1212 scan(tree.typarams);
1213 scan(tree.recvparam);
1214 scan(tree.params);
1215 scan(tree.thrown);
1216 } else {
1217 scan(tree.defaultValue);
1218 scan(tree.body);
1219 }
1220 }
1221
1222 /* Store a reference to the current lambda expression, to
1223 * be used by all type annotations within this expression.
1224 */
1225 private JCLambda currentLambda = null;
1226
1227 public void visitLambda(JCLambda tree) {
1228 JCLambda prevLambda = currentLambda;
1229 try {
1230 currentLambda = tree;
1231
1232 int i = 0;
1233 for (JCVariableDecl param : tree.params) {
1234 if (!param.mods.annotations.isEmpty()) {
1235 // Nothing to do for separateAnnotationsKinds if
1236 // there are no annotations of either kind.
1237 final TypeAnnotationPosition pos = TypeAnnotationPosition
1238 .methodParameter(tree, i, param.vartype.pos);
1239 push(param);
1240 try {
1241 if (!param.declaredUsingVar()) {
1242 separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
1243 }
1244 } finally {
1245 pop();
1246 }
1247 }
1248 ++i;
1249 }
1250
1251 scan(tree.body);
1252 scan(tree.params);
1253 } finally {
1254 currentLambda = prevLambda;
1255 }
1256 }
1257
1258 /**
1259 * Resolve declaration vs. type annotations in variable declarations and
1260 * then determine the positions.
1261 */
1262 @Override
1263 public void visitVarDef(final JCVariableDecl tree) {
1264 if (tree.mods.annotations.isEmpty()) {
1265 // Nothing to do for separateAnnotationsKinds if
1266 // there are no annotations of either kind.
1267 } else if (tree.sym == null) {
1268 Assert.error("Visiting tree node before memberEnter");
1269 } else if (tree.sym.getKind() == ElementKind.PARAMETER) {
1270 // Parameters are handled in visitMethodDef or visitLambda.
1271 } else if (tree.sym.getKind() == ElementKind.FIELD) {
1272 if (sigOnly) {
1273 TypeAnnotationPosition pos =
1274 TypeAnnotationPosition.field(tree.pos);
1275 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
1276 }
1277 } else if (tree.sym.getKind() == ElementKind.LOCAL_VARIABLE) {
1278 final TypeAnnotationPosition pos =
1279 TypeAnnotationPosition.localVariable(currentLambda,
1280 tree.pos);
1281 if (!tree.declaredUsingVar()) {
1282 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
1283 }
1284 } else if (tree.sym.getKind() == ElementKind.BINDING_VARIABLE) {
1285 final TypeAnnotationPosition pos =
1286 TypeAnnotationPosition.localVariable(currentLambda,
1287 tree.pos);
1288 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
1289 } else if (tree.sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {
1290 final TypeAnnotationPosition pos =
1291 TypeAnnotationPosition.exceptionParameter(currentLambda,
1292 tree.pos);
1293 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
1294 } else if (tree.sym.getKind() == ElementKind.RESOURCE_VARIABLE) {
1295 final TypeAnnotationPosition pos =
1296 TypeAnnotationPosition.resourceVariable(currentLambda,
1297 tree.pos);
1298 separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
1299 } else if (tree.sym.getKind() == ElementKind.ENUM_CONSTANT) {
1300 // No type annotations can occur here.
1301 } else {
1302 // There is nothing else in a variable declaration that needs separation.
1303 Assert.error("Unhandled variable kind: " + tree.sym.getKind());
1304 }
1305
1306 scan(tree.mods);
1307 scan(tree.vartype);
1308 if (!sigOnly) {
1309 scan(tree.init);
1310 }
1311
1312 // Now that type and declaration annotations have been segregated into their own buckets ...
1313 if (sigOnly) {
1314 if (tree.sym != null && tree.sym.getKind() == ElementKind.FIELD && (tree.sym.flags_field & RECORD) != 0) {
1315 RecordComponent rc = ((ClassSymbol)tree.sym.owner).getRecordComponent(tree.sym);
1316 rc.setTypeAttributes(tree.sym.getRawTypeAttributes());
1317 // to get all the type annotations applied to the type
1318 rc.type = tree.sym.type;
1319 }
1320 }
1321 }
1322
1323 @Override
1324 public void visitBlock(JCBlock tree) {
1325 // Do not descend into top-level blocks when only interested
1326 // in the signature.
1327 if (!sigOnly) {
1328 scan(tree.stats);
1329 }
1330 }
1331
1332 @Override
1333 public void visitAnnotatedType(JCAnnotatedType tree) {
1334 push(tree);
1335 findPosition(tree, tree, tree.annotations);
1336 pop();
1337 super.visitAnnotatedType(tree);
1338 }
1339
1340 @Override
1341 public void visitTypeParameter(JCTypeParameter tree) {
1342 findPosition(tree, peek2(), tree.annotations);
1343 super.visitTypeParameter(tree);
1344 }
1345
1346 private void propagateNewClassAnnotationsToOwner(JCNewClass tree) {
1347 Symbol sym = tree.def.sym;
1348 // The anonymous class' synthetic class declaration is itself an inner class,
1349 // so the type path is one INNER_TYPE entry deeper than that of the
1350 // lexically enclosing class.
1351 List<TypePathEntry> depth =
1352 locateNestedTypes(sym.owner.enclClass().type, new ListBuffer<>())
1353 .append(TypePathEntry.INNER_TYPE).toList();
1354 TypeAnnotationPosition pos =
1355 TypeAnnotationPosition.newObj(depth, /* currentLambda= */ null, tree.pos);
1356
1357 ListBuffer<Attribute.TypeCompound> newattrs = new ListBuffer<>();
1358 List<TypePathEntry> expectedLocation =
1359 locateNestedTypes(tree.clazz.type, new ListBuffer<>()).toList();
1360 for (Attribute.TypeCompound old : sym.getRawTypeAttributes()) {
1361 // Only propagate type annotations from the top-level supertype,
1362 // (including if the supertype is an inner class).
1363 if (old.position.location.equals(expectedLocation)) {
1364 newattrs.append(new Attribute.TypeCompound(old.type, old.values, pos));
1365 }
1366 }
1367
1368 sym.owner.appendUniqueTypeAttributes(newattrs.toList());
1369 }
1370
1371 @Override
1372 public void visitNewClass(JCNewClass tree) {
1373 if (tree.def != null && tree.def.sym != null) {
1374 propagateNewClassAnnotationsToOwner(tree);
1375 }
1376
1377 scan(tree.encl);
1378 scan(tree.typeargs);
1379 if (tree.def == null) {
1380 scan(tree.clazz);
1381 } // else supertype will already have been scanned in the context of the anonymous class.
1382 scan(tree.args);
1383
1384 // The class body will already be scanned.
1385 // scan(tree.def);
1386 }
1387
1388 @Override
1389 public void visitNewArray(JCNewArray tree) {
1390 findPosition(tree, tree, tree.annotations);
1391 int dimAnnosCount = tree.dimAnnotations.size();
1392 ListBuffer<TypePathEntry> depth = new ListBuffer<>();
1393
1394 // handle annotations associated with dimensions
1395 for (int i = 0; i < dimAnnosCount; ++i) {
1396 ListBuffer<TypePathEntry> location =
1397 new ListBuffer<TypePathEntry>();
1398 if (i != 0) {
1399 depth = depth.append(TypePathEntry.ARRAY);
1400 location = location.appendList(depth.toList());
1401 }
1402 final TypeAnnotationPosition p =
1403 TypeAnnotationPosition.newObj(location.toList(),
1404 currentLambda,
1405 tree.pos);
1406
1407 setTypeAnnotationPos(tree.dimAnnotations.get(i), p);
1408 }
1409
1410 // handle "free" annotations
1411 // int i = dimAnnosCount == 0 ? 0 : dimAnnosCount - 1;
1412 // TODO: is depth.size == i here?
1413 JCExpression elemType = tree.elemtype;
1414 depth = depth.append(TypePathEntry.ARRAY);
1415 while (elemType != null) {
1416 if (elemType.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
1417 JCAnnotatedType at = (JCAnnotatedType)elemType;
1418 final ListBuffer<TypePathEntry> locationbuf =
1419 locateNestedTypes(elemType.type,
1420 new ListBuffer<TypePathEntry>());
1421 final List<TypePathEntry> location =
1422 locationbuf.toList().prependList(depth.toList());
1423 final TypeAnnotationPosition p =
1424 TypeAnnotationPosition.newObj(location, currentLambda,
1425 tree.pos);
1426 setTypeAnnotationPos(at.annotations, p);
1427 elemType = at.underlyingType;
1428 } else if (elemType.hasTag(JCTree.Tag.TYPEARRAY)) {
1429 depth = depth.append(TypePathEntry.ARRAY);
1430 elemType = ((JCArrayTypeTree)elemType).elemtype;
1431 } else if (elemType.hasTag(JCTree.Tag.SELECT)) {
1432 elemType = ((JCFieldAccess)elemType).selected;
1433 } else {
1434 break;
1435 }
1436 }
1437 scan(tree.elems);
1438 }
1439
1440 private void findPosition(JCTree tree, JCTree frame, List<JCAnnotation> annotations) {
1441 if (!annotations.isEmpty())
1442 {
1443 final TypeAnnotationPosition p =
1444 resolveFrame(tree, frame, frames, currentLambda, 0, new ListBuffer<>());
1445
1446 setTypeAnnotationPos(annotations, p);
1447 }
1448 }
1449
1450 private void setTypeAnnotationPos(List<JCAnnotation> annotations, TypeAnnotationPosition position)
1451 {
1452 // attribute might be null during DeferredAttr;
1453 // we will be back later.
1454 for (JCAnnotation anno : annotations) {
1455 if (anno.attribute != null)
1456 ((Attribute.TypeCompound) anno.attribute).position = position;
1457 }
1458 }
1459
1460
1461 @Override
1462 public String toString() {
1463 return super.toString() + ": sigOnly: " + sigOnly;
1464 }
1465 }
1466 }