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