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