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