1/* 2 * Copyright (c) 2005, 2017, 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.model; 27 28import java.util.Collections; 29import java.util.HashSet; 30import java.util.LinkedHashSet; 31import java.util.Map; 32import java.util.Set; 33import java.util.stream.Collectors; 34 35import javax.lang.model.AnnotatedConstruct; 36import javax.lang.model.SourceVersion; 37import javax.lang.model.element.*; 38import javax.lang.model.type.DeclaredType; 39import javax.lang.model.util.Elements; 40import javax.tools.JavaFileObject; 41import static javax.lang.model.util.ElementFilter.methodsIn; 42 43import com.sun.source.util.JavacTask; 44import com.sun.tools.javac.api.JavacTaskImpl; 45import com.sun.tools.javac.code.*; 46import com.sun.tools.javac.code.Attribute.Compound; 47import com.sun.tools.javac.code.Directive.ExportsDirective; 48import com.sun.tools.javac.code.Directive.ExportsFlag; 49import com.sun.tools.javac.code.Directive.OpensDirective; 50import com.sun.tools.javac.code.Directive.OpensFlag; 51import com.sun.tools.javac.code.Directive.RequiresDirective; 52import com.sun.tools.javac.code.Directive.RequiresFlag; 53import com.sun.tools.javac.code.Scope.WriteableScope; 54import com.sun.tools.javac.code.Symbol.*; 55import com.sun.tools.javac.comp.AttrContext; 56import com.sun.tools.javac.comp.Enter; 57import com.sun.tools.javac.comp.Env; 58import com.sun.tools.javac.main.JavaCompiler; 59import com.sun.tools.javac.processing.PrintingProcessor; 60import com.sun.tools.javac.tree.JCTree; 61import com.sun.tools.javac.tree.JCTree.*; 62import com.sun.tools.javac.tree.TreeInfo; 63import com.sun.tools.javac.tree.TreeScanner; 64import com.sun.tools.javac.util.*; 65import com.sun.tools.javac.util.DefinedBy.Api; 66import com.sun.tools.javac.util.Name; 67import static com.sun.tools.javac.code.Kinds.Kind.*; 68import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE; 69import static com.sun.tools.javac.code.TypeTag.CLASS; 70import com.sun.tools.javac.comp.Modules; 71import com.sun.tools.javac.comp.Resolve; 72import com.sun.tools.javac.comp.Resolve.RecoveryLoadClass; 73import com.sun.tools.javac.resources.CompilerProperties.Notes; 74import static com.sun.tools.javac.tree.JCTree.Tag.*; 75 76/** 77 * Utility methods for operating on program elements. 78 * 79 * <p><b>This is NOT part of any supported API. 80 * If you write code that depends on this, you do so at your own 81 * risk. This code and its internal interfaces are subject to change 82 * or deletion without notice.</b></p> 83 */ 84public class JavacElements implements Elements { 85 86 private final JavaCompiler javaCompiler; 87 private final Symtab syms; 88 private final Modules modules; 89 private final Names names; 90 private final Types types; 91 private final Enter enter; 92 private final Resolve resolve; 93 private final JavacTaskImpl javacTaskImpl; 94 private final Log log; 95 private final boolean allowModules; 96 97 public static JavacElements instance(Context context) { 98 JavacElements instance = context.get(JavacElements.class); 99 if (instance == null) 100 instance = new JavacElements(context); 101 return instance; 102 } 103 104 protected JavacElements(Context context) { 105 context.put(JavacElements.class, this); 106 javaCompiler = JavaCompiler.instance(context); 107 syms = Symtab.instance(context); 108 modules = Modules.instance(context); 109 names = Names.instance(context); 110 types = Types.instance(context); 111 enter = Enter.instance(context); 112 resolve = Resolve.instance(context); 113 JavacTask t = context.get(JavacTask.class); 114 javacTaskImpl = t instanceof JavacTaskImpl ? (JavacTaskImpl) t : null; 115 log = Log.instance(context); 116 Source source = Source.instance(context); 117 allowModules = source.allowModules(); 118 } 119 120 @Override @DefinedBy(Api.LANGUAGE_MODEL) 121 public Set<? extends ModuleElement> getAllModuleElements() { 122 if (allowModules) 123 return Collections.unmodifiableSet(modules.allModules()); 124 else 125 return Collections.emptySet(); 126 } 127 128 @Override @DefinedBy(Api.LANGUAGE_MODEL) 129 public ModuleSymbol getModuleElement(CharSequence name) { 130 ensureEntered("getModuleElement"); 131 if (modules.getDefaultModule() == syms.noModule) 132 return null; 133 String strName = name.toString(); 134 if (strName.equals("")) 135 return syms.unnamedModule; 136 return modules.getObservableModule(names.fromString(strName)); 137 } 138 139 @Override @DefinedBy(Api.LANGUAGE_MODEL) 140 public PackageSymbol getPackageElement(CharSequence name) { 141 return doGetPackageElement(null, name); 142 } 143 144 @Override @DefinedBy(Api.LANGUAGE_MODEL) 145 public PackageSymbol getPackageElement(ModuleElement module, CharSequence name) { 146 module.getClass(); 147 return doGetPackageElement(module, name); 148 } 149 150 private PackageSymbol doGetPackageElement(ModuleElement module, CharSequence name) { 151 ensureEntered("getPackageElement"); 152 return doGetElement(module, "getPackageElement", name, PackageSymbol.class); 153 } 154 155 @Override @DefinedBy(Api.LANGUAGE_MODEL) 156 public ClassSymbol getTypeElement(CharSequence name) { 157 return doGetTypeElement(null, name); 158 } 159 160 @Override @DefinedBy(Api.LANGUAGE_MODEL) 161 public ClassSymbol getTypeElement(ModuleElement module, CharSequence name) { 162 module.getClass(); 163 164 return doGetTypeElement(module, name); 165 } 166 167 private ClassSymbol doGetTypeElement(ModuleElement module, CharSequence name) { 168 ensureEntered("getTypeElement"); 169 return doGetElement(module, "getTypeElement", name, ClassSymbol.class); 170 } 171 172 private <S extends Symbol> S doGetElement(ModuleElement module, String methodName, 173 CharSequence name, Class<S> clazz) { 174 String strName = name.toString(); 175 if (!SourceVersion.isName(strName) && (!strName.isEmpty() || clazz == ClassSymbol.class)) { 176 return null; 177 } 178 if (module == null) { 179 return unboundNameToSymbol(methodName, strName, clazz); 180 } else { 181 return nameToSymbol((ModuleSymbol) module, strName, clazz); 182 } 183 } 184 185 private final Set<String> alreadyWarnedDuplicates = new HashSet<>(); 186 187 private <S extends Symbol> S unboundNameToSymbol(String methodName, 188 String nameStr, 189 Class<S> clazz) { 190 if (modules.getDefaultModule() == syms.noModule) { //not a modular mode: 191 return nameToSymbol(syms.noModule, nameStr, clazz); 192 } 193 194 Set<S> found = new LinkedHashSet<>(); 195 196 for (ModuleSymbol msym : modules.allModules()) { 197 S sym = nameToSymbol(msym, nameStr, clazz); 198 199 if (sym != null) { 200 if (!allowModules || clazz == ClassSymbol.class || !sym.members().isEmpty()) { 201 //do not add packages without members: 202 found.add(sym); 203 } 204 } 205 } 206 207 if (found.size() == 1) { 208 return found.iterator().next(); 209 } else if (found.size() > 1) { 210 //more than one element found, produce a note: 211 if (alreadyWarnedDuplicates.add(methodName + ":" + nameStr)) { 212 String moduleNames = found.stream() 213 .map(s -> s.packge().modle) 214 .map(m -> m.toString()) 215 .collect(Collectors.joining(", ")); 216 log.note(Notes.MultipleElements(methodName, nameStr, moduleNames)); 217 } 218 return null; 219 } else { 220 //not found, or more than one element found: 221 return null; 222 } 223 } 224 225 /** 226 * Returns a symbol given the type's or package's canonical name, 227 * or null if the name isn't found. 228 */ 229 private <S extends Symbol> S nameToSymbol(ModuleSymbol module, String nameStr, Class<S> clazz) { 230 Name name = names.fromString(nameStr); 231 // First check cache. 232 Symbol sym = (clazz == ClassSymbol.class) 233 ? syms.getClass(module, name) 234 : syms.lookupPackage(module, name); 235 236 try { 237 if (sym == null) 238 sym = javaCompiler.resolveIdent(module, nameStr); 239 240 sym.complete(); 241 242 return (sym.kind != ERR && 243 sym.exists() && 244 clazz.isInstance(sym) && 245 name.equals(sym.getQualifiedName())) 246 ? clazz.cast(sym) 247 : null; 248 } catch (CompletionFailure e) { 249 return null; 250 } 251 } 252 253 /** 254 * Returns the tree for an annotation given the annotated element 255 * and the element's own tree. Returns null if the tree cannot be found. 256 */ 257 private JCTree matchAnnoToTree(AnnotationMirror findme, 258 Element e, JCTree tree) { 259 Symbol sym = cast(Symbol.class, e); 260 class Vis extends JCTree.Visitor { 261 List<JCAnnotation> result = null; 262 public void visitPackageDef(JCPackageDecl tree) { 263 result = tree.annotations; 264 } 265 public void visitClassDef(JCClassDecl tree) { 266 result = tree.mods.annotations; 267 } 268 public void visitMethodDef(JCMethodDecl tree) { 269 result = tree.mods.annotations; 270 } 271 public void visitVarDef(JCVariableDecl tree) { 272 result = tree.mods.annotations; 273 } 274 @Override 275 public void visitTypeParameter(JCTypeParameter tree) { 276 result = tree.annotations; 277 } 278 } 279 Vis vis = new Vis(); 280 tree.accept(vis); 281 if (vis.result == null) 282 return null; 283 284 List<Attribute.Compound> annos = sym.getAnnotationMirrors(); 285 return matchAnnoToTree(cast(Attribute.Compound.class, findme), 286 annos, 287 vis.result); 288 } 289 290 /** 291 * Returns the tree for an annotation given a list of annotations 292 * in which to search (recursively) and their corresponding trees. 293 * Returns null if the tree cannot be found. 294 */ 295 private JCTree matchAnnoToTree(Attribute.Compound findme, 296 List<Attribute.Compound> annos, 297 List<JCAnnotation> trees) { 298 for (Attribute.Compound anno : annos) { 299 for (JCAnnotation tree : trees) { 300 if (tree.type.tsym != anno.type.tsym) 301 continue; 302 JCTree match = matchAttributeToTree(findme, anno, tree); 303 if (match != null) 304 return match; 305 } 306 } 307 return null; 308 } 309 310 /** 311 * Returns the tree for an attribute given an enclosing attribute to 312 * search (recursively) and the enclosing attribute's corresponding tree. 313 * Returns null if the tree cannot be found. 314 */ 315 private JCTree matchAttributeToTree(final Attribute findme, 316 final Attribute attr, 317 final JCTree tree) { 318 if (attr == findme) 319 return tree; 320 321 class Vis implements Attribute.Visitor { 322 JCTree result = null; 323 public void visitConstant(Attribute.Constant value) { 324 } 325 public void visitClass(Attribute.Class clazz) { 326 } 327 public void visitCompound(Attribute.Compound anno) { 328 for (Pair<MethodSymbol, Attribute> pair : anno.values) { 329 JCExpression expr = scanForAssign(pair.fst, tree); 330 if (expr != null) { 331 JCTree match = matchAttributeToTree(findme, pair.snd, expr); 332 if (match != null) { 333 result = match; 334 return; 335 } 336 } 337 } 338 } 339 public void visitArray(Attribute.Array array) { 340 if (tree.hasTag(NEWARRAY)) { 341 List<JCExpression> elems = ((JCNewArray)tree).elems; 342 for (Attribute value : array.values) { 343 JCTree match = matchAttributeToTree(findme, value, elems.head); 344 if (match != null) { 345 result = match; 346 return; 347 } 348 elems = elems.tail; 349 } 350 } else if (array.values.length == 1) { 351 // the tree may not be a NEWARRAY for single-element array initializers 352 result = matchAttributeToTree(findme, array.values[0], tree); 353 } 354 } 355 public void visitEnum(Attribute.Enum e) { 356 } 357 public void visitError(Attribute.Error e) { 358 } 359 } 360 Vis vis = new Vis(); 361 attr.accept(vis); 362 return vis.result; 363 } 364 365 /** 366 * Scans for a JCAssign node with a LHS matching a given 367 * symbol, and returns its RHS. Does not scan nested JCAnnotations. 368 */ 369 private JCExpression scanForAssign(final MethodSymbol sym, 370 final JCTree tree) { 371 class TS extends TreeScanner { 372 JCExpression result = null; 373 public void scan(JCTree t) { 374 if (t != null && result == null) 375 t.accept(this); 376 } 377 public void visitAnnotation(JCAnnotation t) { 378 if (t == tree) 379 scan(t.args); 380 } 381 public void visitAssign(JCAssign t) { 382 if (t.lhs.hasTag(IDENT)) { 383 JCIdent ident = (JCIdent) t.lhs; 384 if (ident.sym == sym) 385 result = t.rhs; 386 } 387 } 388 } 389 TS scanner = new TS(); 390 tree.accept(scanner); 391 return scanner.result; 392 } 393 394 /** 395 * Returns the tree node corresponding to this element, or null 396 * if none can be found. 397 */ 398 public JCTree getTree(Element e) { 399 Pair<JCTree, ?> treeTop = getTreeAndTopLevel(e); 400 return (treeTop != null) ? treeTop.fst : null; 401 } 402 403 @DefinedBy(Api.LANGUAGE_MODEL) 404 public String getDocComment(Element e) { 405 // Our doc comment is contained in a map in our toplevel, 406 // indexed by our tree. Find our enter environment, which gives 407 // us our toplevel. It also gives us a tree that contains our 408 // tree: walk it to find our tree. This is painful. 409 Pair<JCTree, JCCompilationUnit> treeTop = getTreeAndTopLevel(e); 410 if (treeTop == null) 411 return null; 412 JCTree tree = treeTop.fst; 413 JCCompilationUnit toplevel = treeTop.snd; 414 if (toplevel.docComments == null) 415 return null; 416 return toplevel.docComments.getCommentText(tree); 417 } 418 419 @DefinedBy(Api.LANGUAGE_MODEL) 420 public PackageElement getPackageOf(Element e) { 421 return cast(Symbol.class, e).packge(); 422 } 423 424 @DefinedBy(Api.LANGUAGE_MODEL) 425 public ModuleElement getModuleOf(Element e) { 426 Symbol sym = cast(Symbol.class, e); 427 if (modules.getDefaultModule() == syms.noModule) 428 return null; 429 return (sym.kind == MDL) ? ((ModuleElement) e) : sym.packge().modle; 430 } 431 432 @DefinedBy(Api.LANGUAGE_MODEL) 433 public boolean isDeprecated(Element e) { 434 Symbol sym = cast(Symbol.class, e); 435 sym.complete(); 436 return sym.isDeprecated(); 437 } 438 439 @Override @DefinedBy(Api.LANGUAGE_MODEL) 440 public Origin getOrigin(Element e) { 441 Symbol sym = cast(Symbol.class, e); 442 if ((sym.flags() & Flags.GENERATEDCONSTR) != 0) 443 return Origin.MANDATED; 444 //TypeElement.getEnclosedElements does not return synthetic elements, 445 //and most synthetic elements are not read from the classfile anyway: 446 return Origin.EXPLICIT; 447 } 448 449 @Override @DefinedBy(Api.LANGUAGE_MODEL) 450 public Origin getOrigin(AnnotatedConstruct c, AnnotationMirror a) { 451 Compound ac = cast(Compound.class, a); 452 if (ac.isSynthesized()) 453 return Origin.MANDATED; 454 return Origin.EXPLICIT; 455 } 456 457 @Override @DefinedBy(Api.LANGUAGE_MODEL) 458 public Origin getOrigin(ModuleElement m, ModuleElement.Directive directive) { 459 switch (directive.getKind()) { 460 case REQUIRES: 461 RequiresDirective rd = cast(RequiresDirective.class, directive); 462 if (rd.flags.contains(RequiresFlag.MANDATED)) 463 return Origin.MANDATED; 464 if (rd.flags.contains(RequiresFlag.SYNTHETIC)) 465 return Origin.SYNTHETIC; 466 return Origin.EXPLICIT; 467 case EXPORTS: 468 ExportsDirective ed = cast(ExportsDirective.class, directive); 469 if (ed.flags.contains(ExportsFlag.MANDATED)) 470 return Origin.MANDATED; 471 if (ed.flags.contains(ExportsFlag.SYNTHETIC)) 472 return Origin.SYNTHETIC; 473 return Origin.EXPLICIT; 474 case OPENS: 475 OpensDirective od = cast(OpensDirective.class, directive); 476 if (od.flags.contains(OpensFlag.MANDATED)) 477 return Origin.MANDATED; 478 if (od.flags.contains(OpensFlag.SYNTHETIC)) 479 return Origin.SYNTHETIC; 480 return Origin.EXPLICIT; 481 } 482 return Origin.EXPLICIT; 483 } 484 485 @DefinedBy(Api.LANGUAGE_MODEL) 486 public Name getBinaryName(TypeElement type) { 487 return cast(TypeSymbol.class, type).flatName(); 488 } 489 490 @DefinedBy(Api.LANGUAGE_MODEL) 491 public Map<MethodSymbol, Attribute> getElementValuesWithDefaults( 492 AnnotationMirror a) { 493 Attribute.Compound anno = cast(Attribute.Compound.class, a); 494 DeclaredType annotype = a.getAnnotationType(); 495 Map<MethodSymbol, Attribute> valmap = anno.getElementValues(); 496 497 for (ExecutableElement ex : 498 methodsIn(annotype.asElement().getEnclosedElements())) { 499 MethodSymbol meth = (MethodSymbol) ex; 500 Attribute defaultValue = meth.getDefaultValue(); 501 if (defaultValue != null && !valmap.containsKey(meth)) { 502 valmap.put(meth, defaultValue); 503 } 504 } 505 return valmap; 506 } 507 508 /** 509 * {@inheritDoc} 510 */ 511 @DefinedBy(Api.LANGUAGE_MODEL) 512 public FilteredMemberList getAllMembers(TypeElement element) { 513 Symbol sym = cast(Symbol.class, element); 514 WriteableScope scope = sym.members().dupUnshared(); 515 List<Type> closure = types.closure(sym.asType()); 516 for (Type t : closure) 517 addMembers(scope, t); 518 return new FilteredMemberList(scope); 519 } 520 // where 521 private void addMembers(WriteableScope scope, Type type) { 522 members: 523 for (Symbol e : type.asElement().members().getSymbols(NON_RECURSIVE)) { 524 for (Symbol overrider : scope.getSymbolsByName(e.getSimpleName())) { 525 if (overrider.kind == e.kind && (overrider.flags() & Flags.SYNTHETIC) == 0) { 526 if (overrider.getKind() == ElementKind.METHOD && 527 overrides((ExecutableElement)overrider, (ExecutableElement)e, (TypeElement)type.asElement())) { 528 continue members; 529 } 530 } 531 } 532 boolean derived = e.getEnclosingElement() != scope.owner; 533 ElementKind kind = e.getKind(); 534 boolean initializer = kind == ElementKind.CONSTRUCTOR 535 || kind == ElementKind.INSTANCE_INIT 536 || kind == ElementKind.STATIC_INIT; 537 if (!derived || (!initializer && e.isInheritedIn(scope.owner, types))) 538 scope.enter(e); 539 } 540 } 541 542 /** 543 * Returns all annotations of an element, whether 544 * inherited or directly present. 545 * 546 * @param e the element being examined 547 * @return all annotations of the element 548 */ 549 @Override @DefinedBy(Api.LANGUAGE_MODEL) 550 public List<Attribute.Compound> getAllAnnotationMirrors(Element e) { 551 Symbol sym = cast(Symbol.class, e); 552 List<Attribute.Compound> annos = sym.getAnnotationMirrors(); 553 while (sym.getKind() == ElementKind.CLASS) { 554 Type sup = ((ClassSymbol) sym).getSuperclass(); 555 if (!sup.hasTag(CLASS) || sup.isErroneous() || 556 sup.tsym == syms.objectType.tsym) { 557 break; 558 } 559 sym = sup.tsym; 560 List<Attribute.Compound> oldAnnos = annos; 561 List<Attribute.Compound> newAnnos = sym.getAnnotationMirrors(); 562 for (Attribute.Compound anno : newAnnos) { 563 if (isInherited(anno.type) && 564 !containsAnnoOfType(oldAnnos, anno.type)) { 565 annos = annos.prepend(anno); 566 } 567 } 568 } 569 return annos; 570 } 571 572 /** 573 * Tests whether an annotation type is @Inherited. 574 */ 575 private boolean isInherited(Type annotype) { 576 return annotype.tsym.attribute(syms.inheritedType.tsym) != null; 577 } 578 579 /** 580 * Tests whether a list of annotations contains an annotation 581 * of a given type. 582 */ 583 private static boolean containsAnnoOfType(List<Attribute.Compound> annos, 584 Type type) { 585 for (Attribute.Compound anno : annos) { 586 if (anno.type.tsym == type.tsym) 587 return true; 588 } 589 return false; 590 } 591 592 @DefinedBy(Api.LANGUAGE_MODEL) 593 public boolean hides(Element hiderEl, Element hideeEl) { 594 Symbol hider = cast(Symbol.class, hiderEl); 595 Symbol hidee = cast(Symbol.class, hideeEl); 596 597 // Fields only hide fields; methods only methods; types only types. 598 // Names must match. Nothing hides itself (just try it). 599 if (hider == hidee || 600 hider.kind != hidee.kind || 601 hider.name != hidee.name) { 602 return false; 603 } 604 605 // Only static methods can hide other methods. 606 // Methods only hide methods with matching signatures. 607 if (hider.kind == MTH) { 608 if (!hider.isStatic() || 609 !types.isSubSignature(hider.type, hidee.type)) { 610 return false; 611 } 612 } 613 614 // Hider must be in a subclass of hidee's class. 615 // Note that if M1 hides M2, and M2 hides M3, and M3 is accessible 616 // in M1's class, then M1 and M2 both hide M3. 617 ClassSymbol hiderClass = hider.owner.enclClass(); 618 ClassSymbol hideeClass = hidee.owner.enclClass(); 619 if (hiderClass == null || hideeClass == null || 620 !hiderClass.isSubClass(hideeClass, types)) { 621 return false; 622 } 623 624 // Hidee must be accessible in hider's class. 625 // The method isInheritedIn is poorly named: it checks only access. 626 return hidee.isInheritedIn(hiderClass, types); 627 } 628 629 @DefinedBy(Api.LANGUAGE_MODEL) 630 public boolean overrides(ExecutableElement riderEl, 631 ExecutableElement rideeEl, TypeElement typeEl) { 632 MethodSymbol rider = cast(MethodSymbol.class, riderEl); 633 MethodSymbol ridee = cast(MethodSymbol.class, rideeEl); 634 ClassSymbol origin = cast(ClassSymbol.class, typeEl); 635 636 return rider.name == ridee.name && 637 638 // not reflexive as per JLS 639 rider != ridee && 640 641 // we don't care if ridee is static, though that wouldn't 642 // compile 643 !rider.isStatic() && 644 645 // Symbol.overrides assumes the following 646 ridee.isMemberOf(origin, types) && 647 648 // check access and signatures; don't check return types 649 rider.overrides(ridee, origin, types, false); 650 } 651 652 @DefinedBy(Api.LANGUAGE_MODEL) 653 public String getConstantExpression(Object value) { 654 return Constants.format(value); 655 } 656 657 /** 658 * Print a representation of the elements to the given writer in 659 * the specified order. The main purpose of this method is for 660 * diagnostics. The exact format of the output is <em>not</em> 661 * specified and is subject to change. 662 * 663 * @param w the writer to print the output to 664 * @param elements the elements to print 665 */ 666 @DefinedBy(Api.LANGUAGE_MODEL) 667 public void printElements(java.io.Writer w, Element... elements) { 668 for (Element element : elements) 669 (new PrintingProcessor.PrintingElementVisitor(w, this)).visit(element).flush(); 670 } 671 672 @DefinedBy(Api.LANGUAGE_MODEL) 673 public Name getName(CharSequence cs) { 674 return names.fromString(cs.toString()); 675 } 676 677 @Override @DefinedBy(Api.LANGUAGE_MODEL) 678 public boolean isFunctionalInterface(TypeElement element) { 679 if (element.getKind() != ElementKind.INTERFACE) 680 return false; 681 else { 682 TypeSymbol tsym = cast(TypeSymbol.class, element); 683 return types.isFunctionalInterface(tsym); 684 } 685 } 686 687 /** 688 * Returns the tree node and compilation unit corresponding to this 689 * element, or null if they can't be found. 690 */ 691 private Pair<JCTree, JCCompilationUnit> getTreeAndTopLevel(Element e) { 692 Symbol sym = cast(Symbol.class, e); 693 Env<AttrContext> enterEnv = getEnterEnv(sym); 694 if (enterEnv == null) 695 return null; 696 JCTree tree = TreeInfo.declarationFor(sym, enterEnv.tree); 697 if (tree == null || enterEnv.toplevel == null) 698 return null; 699 return new Pair<>(tree, enterEnv.toplevel); 700 } 701 702 /** 703 * Returns the best approximation for the tree node and compilation unit 704 * corresponding to the given element, annotation and value. 705 * If the element is null, null is returned. 706 * If the annotation is null or cannot be found, the tree node and 707 * compilation unit for the element is returned. 708 * If the annotation value is null or cannot be found, the tree node and 709 * compilation unit for the annotation is returned. 710 */ 711 public Pair<JCTree, JCCompilationUnit> getTreeAndTopLevel( 712 Element e, AnnotationMirror a, AnnotationValue v) { 713 if (e == null) 714 return null; 715 716 Pair<JCTree, JCCompilationUnit> elemTreeTop = getTreeAndTopLevel(e); 717 if (elemTreeTop == null) 718 return null; 719 720 if (a == null) 721 return elemTreeTop; 722 723 JCTree annoTree = matchAnnoToTree(a, e, elemTreeTop.fst); 724 if (annoTree == null) 725 return elemTreeTop; 726 727 if (v == null) 728 return new Pair<>(annoTree, elemTreeTop.snd); 729 730 JCTree valueTree = matchAttributeToTree( 731 cast(Attribute.class, v), cast(Attribute.class, a), annoTree); 732 if (valueTree == null) 733 return new Pair<>(annoTree, elemTreeTop.snd); 734 735 return new Pair<>(valueTree, elemTreeTop.snd); 736 } 737 738 /** 739 * Returns a symbol's enter environment, or null if it has none. 740 */ 741 private Env<AttrContext> getEnterEnv(Symbol sym) { 742 // Get enclosing class of sym, or sym itself if it is a class 743 // package, or module. 744 TypeSymbol ts = null; 745 switch (sym.kind) { 746 case PCK: 747 ts = (PackageSymbol)sym; 748 break; 749 case MDL: 750 ts = (ModuleSymbol)sym; 751 break; 752 default: 753 ts = sym.enclClass(); 754 } 755 return (ts != null) 756 ? enter.getEnv(ts) 757 : null; 758 } 759 760 private void ensureEntered(String methodName) { 761 if (javacTaskImpl != null) { 762 javacTaskImpl.ensureEntered(); 763 } 764 if (!javaCompiler.isEnterDone()) { 765 throw new IllegalStateException("Cannot use Elements." + methodName + " before the TaskEvent.Kind.ENTER finished event."); 766 } 767 } 768 769 /** 770 * Returns an object cast to the specified type. 771 * @throws NullPointerException if the object is {@code null} 772 * @throws IllegalArgumentException if the object is of the wrong type 773 */ 774 private static <T> T cast(Class<T> clazz, Object o) { 775 if (! clazz.isInstance(o)) 776 throw new IllegalArgumentException(o.toString()); 777 return clazz.cast(o); 778 } 779} 780