609 lines
22 KiB
Java
609 lines
22 KiB
Java
/*
|
|
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.javac.model;
|
|
|
|
import java.util.Map;
|
|
|
|
import javax.lang.model.SourceVersion;
|
|
import javax.lang.model.element.*;
|
|
import javax.lang.model.type.DeclaredType;
|
|
import javax.lang.model.util.Elements;
|
|
import javax.tools.JavaFileObject;
|
|
import static javax.lang.model.util.ElementFilter.methodsIn;
|
|
|
|
import com.sun.tools.javac.code.*;
|
|
import com.sun.tools.javac.code.Symbol.*;
|
|
import com.sun.tools.javac.comp.AttrContext;
|
|
import com.sun.tools.javac.comp.Enter;
|
|
import com.sun.tools.javac.comp.Env;
|
|
import com.sun.tools.javac.main.JavaCompiler;
|
|
import com.sun.tools.javac.processing.PrintingProcessor;
|
|
import com.sun.tools.javac.tree.JCTree;
|
|
import com.sun.tools.javac.tree.JCTree.*;
|
|
import com.sun.tools.javac.tree.TreeInfo;
|
|
import com.sun.tools.javac.tree.TreeScanner;
|
|
import com.sun.tools.javac.util.*;
|
|
import com.sun.tools.javac.util.Name;
|
|
import static com.sun.tools.javac.code.TypeTag.CLASS;
|
|
import static com.sun.tools.javac.tree.JCTree.Tag.*;
|
|
|
|
/**
|
|
* Utility methods for operating on program elements.
|
|
*
|
|
* <p><b>This is NOT part of any supported API.
|
|
* If you write code that depends on this, you do so at your own
|
|
* risk. This code and its internal interfaces are subject to change
|
|
* or deletion without notice.</b></p>
|
|
*/
|
|
public class JavacElements implements Elements {
|
|
|
|
private JavaCompiler javaCompiler;
|
|
private Symtab syms;
|
|
private Names names;
|
|
private Types types;
|
|
private Enter enter;
|
|
|
|
public static JavacElements instance(Context context) {
|
|
JavacElements instance = context.get(JavacElements.class);
|
|
if (instance == null)
|
|
instance = new JavacElements(context);
|
|
return instance;
|
|
}
|
|
|
|
/**
|
|
* Public for use only by JavacProcessingEnvironment
|
|
*/
|
|
protected JavacElements(Context context) {
|
|
setContext(context);
|
|
}
|
|
|
|
/**
|
|
* Use a new context. May be called from outside to update
|
|
* internal state for a new annotation-processing round.
|
|
*/
|
|
public void setContext(Context context) {
|
|
context.put(JavacElements.class, this);
|
|
javaCompiler = JavaCompiler.instance(context);
|
|
syms = Symtab.instance(context);
|
|
names = Names.instance(context);
|
|
types = Types.instance(context);
|
|
enter = Enter.instance(context);
|
|
}
|
|
|
|
public PackageSymbol getPackageElement(CharSequence name) {
|
|
String strName = name.toString();
|
|
if (strName.equals(""))
|
|
return syms.unnamedPackage;
|
|
return SourceVersion.isName(strName)
|
|
? nameToSymbol(strName, PackageSymbol.class)
|
|
: null;
|
|
}
|
|
|
|
public ClassSymbol getTypeElement(CharSequence name) {
|
|
String strName = name.toString();
|
|
return SourceVersion.isName(strName)
|
|
? nameToSymbol(strName, ClassSymbol.class)
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* Returns a symbol given the type's or packages's canonical name,
|
|
* or null if the name isn't found.
|
|
*/
|
|
private <S extends Symbol> S nameToSymbol(String nameStr, Class<S> clazz) {
|
|
Name name = names.fromString(nameStr);
|
|
// First check cache.
|
|
Symbol sym = (clazz == ClassSymbol.class)
|
|
? syms.classes.get(name)
|
|
: syms.packages.get(name);
|
|
|
|
try {
|
|
if (sym == null)
|
|
sym = javaCompiler.resolveIdent(nameStr);
|
|
|
|
sym.complete();
|
|
|
|
return (sym.kind != Kinds.ERR &&
|
|
sym.exists() &&
|
|
clazz.isInstance(sym) &&
|
|
name.equals(sym.getQualifiedName()))
|
|
? clazz.cast(sym)
|
|
: null;
|
|
} catch (CompletionFailure e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public JavacSourcePosition getSourcePosition(Element e) {
|
|
Pair<JCTree, JCCompilationUnit> treeTop = getTreeAndTopLevel(e);
|
|
if (treeTop == null)
|
|
return null;
|
|
JCTree tree = treeTop.fst;
|
|
JCCompilationUnit toplevel = treeTop.snd;
|
|
JavaFileObject sourcefile = toplevel.sourcefile;
|
|
if (sourcefile == null)
|
|
return null;
|
|
return new JavacSourcePosition(sourcefile, tree.pos, toplevel.lineMap);
|
|
}
|
|
|
|
public JavacSourcePosition getSourcePosition(Element e, AnnotationMirror a) {
|
|
Pair<JCTree, JCCompilationUnit> treeTop = getTreeAndTopLevel(e);
|
|
if (treeTop == null)
|
|
return null;
|
|
JCTree tree = treeTop.fst;
|
|
JCCompilationUnit toplevel = treeTop.snd;
|
|
JavaFileObject sourcefile = toplevel.sourcefile;
|
|
if (sourcefile == null)
|
|
return null;
|
|
|
|
JCTree annoTree = matchAnnoToTree(a, e, tree);
|
|
if (annoTree == null)
|
|
return null;
|
|
return new JavacSourcePosition(sourcefile, annoTree.pos,
|
|
toplevel.lineMap);
|
|
}
|
|
|
|
public JavacSourcePosition getSourcePosition(Element e, AnnotationMirror a,
|
|
AnnotationValue v) {
|
|
// TODO: better accuracy in getSourcePosition(... AnnotationValue)
|
|
return getSourcePosition(e, a);
|
|
}
|
|
|
|
/**
|
|
* Returns the tree for an annotation given the annotated element
|
|
* and the element's own tree. Returns null if the tree cannot be found.
|
|
*/
|
|
private JCTree matchAnnoToTree(AnnotationMirror findme,
|
|
Element e, JCTree tree) {
|
|
Symbol sym = cast(Symbol.class, e);
|
|
class Vis extends JCTree.Visitor {
|
|
List<JCAnnotation> result = null;
|
|
public void visitTopLevel(JCCompilationUnit tree) {
|
|
result = tree.packageAnnotations;
|
|
}
|
|
public void visitClassDef(JCClassDecl tree) {
|
|
result = tree.mods.annotations;
|
|
}
|
|
public void visitMethodDef(JCMethodDecl tree) {
|
|
result = tree.mods.annotations;
|
|
}
|
|
public void visitVarDef(JCVariableDecl tree) {
|
|
result = tree.mods.annotations;
|
|
}
|
|
}
|
|
Vis vis = new Vis();
|
|
tree.accept(vis);
|
|
if (vis.result == null)
|
|
return null;
|
|
|
|
List<Attribute.Compound> annos = sym.getRawAttributes();
|
|
return matchAnnoToTree(cast(Attribute.Compound.class, findme),
|
|
annos,
|
|
vis.result);
|
|
}
|
|
|
|
/**
|
|
* Returns the tree for an annotation given a list of annotations
|
|
* in which to search (recursively) and their corresponding trees.
|
|
* Returns null if the tree cannot be found.
|
|
*/
|
|
private JCTree matchAnnoToTree(Attribute.Compound findme,
|
|
List<Attribute.Compound> annos,
|
|
List<JCAnnotation> trees) {
|
|
for (Attribute.Compound anno : annos) {
|
|
for (JCAnnotation tree : trees) {
|
|
JCTree match = matchAnnoToTree(findme, anno, tree);
|
|
if (match != null)
|
|
return match;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the tree for an annotation given an Attribute to
|
|
* search (recursively) and its corresponding tree.
|
|
* Returns null if the tree cannot be found.
|
|
*/
|
|
private JCTree matchAnnoToTree(final Attribute.Compound findme,
|
|
final Attribute attr,
|
|
final JCTree tree) {
|
|
if (attr == findme)
|
|
return (tree.type.tsym == findme.type.tsym) ? tree : null;
|
|
|
|
class Vis implements Attribute.Visitor {
|
|
JCTree result = null;
|
|
public void visitConstant(Attribute.Constant value) {
|
|
}
|
|
public void visitClass(Attribute.Class clazz) {
|
|
}
|
|
public void visitCompound(Attribute.Compound anno) {
|
|
for (Pair<MethodSymbol, Attribute> pair : anno.values) {
|
|
JCExpression expr = scanForAssign(pair.fst, tree);
|
|
if (expr != null) {
|
|
JCTree match = matchAnnoToTree(findme, pair.snd, expr);
|
|
if (match != null) {
|
|
result = match;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void visitArray(Attribute.Array array) {
|
|
if (tree.hasTag(NEWARRAY) &&
|
|
types.elemtype(array.type).tsym == findme.type.tsym) {
|
|
List<JCExpression> elems = ((JCNewArray) tree).elems;
|
|
for (Attribute value : array.values) {
|
|
if (value == findme) {
|
|
result = elems.head;
|
|
return;
|
|
}
|
|
elems = elems.tail;
|
|
}
|
|
}
|
|
}
|
|
public void visitEnum(Attribute.Enum e) {
|
|
}
|
|
public void visitError(Attribute.Error e) {
|
|
}
|
|
}
|
|
Vis vis = new Vis();
|
|
attr.accept(vis);
|
|
return vis.result;
|
|
}
|
|
|
|
/**
|
|
* Scans for a JCAssign node with a LHS matching a given
|
|
* symbol, and returns its RHS. Does not scan nested JCAnnotations.
|
|
*/
|
|
private JCExpression scanForAssign(final MethodSymbol sym,
|
|
final JCTree tree) {
|
|
class TS extends TreeScanner {
|
|
JCExpression result = null;
|
|
public void scan(JCTree t) {
|
|
if (t != null && result == null)
|
|
t.accept(this);
|
|
}
|
|
public void visitAnnotation(JCAnnotation t) {
|
|
if (t == tree)
|
|
scan(t.args);
|
|
}
|
|
public void visitAssign(JCAssign t) {
|
|
if (t.lhs.hasTag(IDENT)) {
|
|
JCIdent ident = (JCIdent) t.lhs;
|
|
if (ident.sym == sym)
|
|
result = t.rhs;
|
|
}
|
|
}
|
|
}
|
|
TS scanner = new TS();
|
|
tree.accept(scanner);
|
|
return scanner.result;
|
|
}
|
|
|
|
/**
|
|
* Returns the tree node corresponding to this element, or null
|
|
* if none can be found.
|
|
*/
|
|
public JCTree getTree(Element e) {
|
|
Pair<JCTree, ?> treeTop = getTreeAndTopLevel(e);
|
|
return (treeTop != null) ? treeTop.fst : null;
|
|
}
|
|
|
|
public String getDocComment(Element e) {
|
|
// Our doc comment is contained in a map in our toplevel,
|
|
// indexed by our tree. Find our enter environment, which gives
|
|
// us our toplevel. It also gives us a tree that contains our
|
|
// tree: walk it to find our tree. This is painful.
|
|
Pair<JCTree, JCCompilationUnit> treeTop = getTreeAndTopLevel(e);
|
|
if (treeTop == null)
|
|
return null;
|
|
JCTree tree = treeTop.fst;
|
|
JCCompilationUnit toplevel = treeTop.snd;
|
|
if (toplevel.docComments == null)
|
|
return null;
|
|
return toplevel.docComments.getCommentText(tree);
|
|
}
|
|
|
|
public PackageElement getPackageOf(Element e) {
|
|
return cast(Symbol.class, e).packge();
|
|
}
|
|
|
|
public boolean isDeprecated(Element e) {
|
|
Symbol sym = cast(Symbol.class, e);
|
|
return (sym.flags() & Flags.DEPRECATED) != 0;
|
|
}
|
|
|
|
public Name getBinaryName(TypeElement type) {
|
|
return cast(TypeSymbol.class, type).flatName();
|
|
}
|
|
|
|
public Map<MethodSymbol, Attribute> getElementValuesWithDefaults(
|
|
AnnotationMirror a) {
|
|
Attribute.Compound anno = cast(Attribute.Compound.class, a);
|
|
DeclaredType annotype = a.getAnnotationType();
|
|
Map<MethodSymbol, Attribute> valmap = anno.getElementValues();
|
|
|
|
for (ExecutableElement ex :
|
|
methodsIn(annotype.asElement().getEnclosedElements())) {
|
|
MethodSymbol meth = (MethodSymbol) ex;
|
|
Attribute defaultValue = meth.getDefaultValue();
|
|
if (defaultValue != null && !valmap.containsKey(meth)) {
|
|
valmap.put(meth, defaultValue);
|
|
}
|
|
}
|
|
return valmap;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public FilteredMemberList getAllMembers(TypeElement element) {
|
|
Symbol sym = cast(Symbol.class, element);
|
|
Scope scope = sym.members().dupUnshared();
|
|
List<Type> closure = types.closure(sym.asType());
|
|
for (Type t : closure)
|
|
addMembers(scope, t);
|
|
return new FilteredMemberList(scope);
|
|
}
|
|
// where
|
|
private void addMembers(Scope scope, Type type) {
|
|
members:
|
|
for (Scope.Entry e = type.asElement().members().elems; e != null; e = e.sibling) {
|
|
Scope.Entry overrider = scope.lookup(e.sym.getSimpleName());
|
|
while (overrider.scope != null) {
|
|
if (overrider.sym.kind == e.sym.kind
|
|
&& (overrider.sym.flags() & Flags.SYNTHETIC) == 0)
|
|
{
|
|
if (overrider.sym.getKind() == ElementKind.METHOD
|
|
&& overrides((ExecutableElement)overrider.sym, (ExecutableElement)e.sym, (TypeElement)type.asElement())) {
|
|
continue members;
|
|
}
|
|
}
|
|
overrider = overrider.next();
|
|
}
|
|
boolean derived = e.sym.getEnclosingElement() != scope.owner;
|
|
ElementKind kind = e.sym.getKind();
|
|
boolean initializer = kind == ElementKind.CONSTRUCTOR
|
|
|| kind == ElementKind.INSTANCE_INIT
|
|
|| kind == ElementKind.STATIC_INIT;
|
|
if (!derived || (!initializer && e.sym.isInheritedIn(scope.owner, types)))
|
|
scope.enter(e.sym);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns all annotations of an element, whether
|
|
* inherited or directly present.
|
|
*
|
|
* @param e the element being examined
|
|
* @return all annotations of the element
|
|
*/
|
|
@Override
|
|
public List<Attribute.Compound> getAllAnnotationMirrors(Element e) {
|
|
Symbol sym = cast(Symbol.class, e);
|
|
List<Attribute.Compound> annos = sym.getAnnotationMirrors();
|
|
while (sym.getKind() == ElementKind.CLASS) {
|
|
Type sup = ((ClassSymbol) sym).getSuperclass();
|
|
if (!sup.hasTag(CLASS) || sup.isErroneous() ||
|
|
sup.tsym == syms.objectType.tsym) {
|
|
break;
|
|
}
|
|
sym = sup.tsym;
|
|
List<Attribute.Compound> oldAnnos = annos;
|
|
List<Attribute.Compound> newAnnos = sym.getAnnotationMirrors();
|
|
for (Attribute.Compound anno : newAnnos) {
|
|
if (isInherited(anno.type) &&
|
|
!containsAnnoOfType(oldAnnos, anno.type)) {
|
|
annos = annos.prepend(anno);
|
|
}
|
|
}
|
|
}
|
|
return annos;
|
|
}
|
|
|
|
/**
|
|
* Tests whether an annotation type is @Inherited.
|
|
*/
|
|
private boolean isInherited(Type annotype) {
|
|
return annotype.tsym.attribute(syms.inheritedType.tsym) != null;
|
|
}
|
|
|
|
/**
|
|
* Tests whether a list of annotations contains an annotation
|
|
* of a given type.
|
|
*/
|
|
private static boolean containsAnnoOfType(List<Attribute.Compound> annos,
|
|
Type type) {
|
|
for (Attribute.Compound anno : annos) {
|
|
if (anno.type.tsym == type.tsym)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean hides(Element hiderEl, Element hideeEl) {
|
|
Symbol hider = cast(Symbol.class, hiderEl);
|
|
Symbol hidee = cast(Symbol.class, hideeEl);
|
|
|
|
// Fields only hide fields; methods only methods; types only types.
|
|
// Names must match. Nothing hides itself (just try it).
|
|
if (hider == hidee ||
|
|
hider.kind != hidee.kind ||
|
|
hider.name != hidee.name) {
|
|
return false;
|
|
}
|
|
|
|
// Only static methods can hide other methods.
|
|
// Methods only hide methods with matching signatures.
|
|
if (hider.kind == Kinds.MTH) {
|
|
if (!hider.isStatic() ||
|
|
!types.isSubSignature(hider.type, hidee.type)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Hider must be in a subclass of hidee's class.
|
|
// Note that if M1 hides M2, and M2 hides M3, and M3 is accessible
|
|
// in M1's class, then M1 and M2 both hide M3.
|
|
ClassSymbol hiderClass = hider.owner.enclClass();
|
|
ClassSymbol hideeClass = hidee.owner.enclClass();
|
|
if (hiderClass == null || hideeClass == null ||
|
|
!hiderClass.isSubClass(hideeClass, types)) {
|
|
return false;
|
|
}
|
|
|
|
// Hidee must be accessible in hider's class.
|
|
// The method isInheritedIn is poorly named: it checks only access.
|
|
return hidee.isInheritedIn(hiderClass, types);
|
|
}
|
|
|
|
public boolean overrides(ExecutableElement riderEl,
|
|
ExecutableElement rideeEl, TypeElement typeEl) {
|
|
MethodSymbol rider = cast(MethodSymbol.class, riderEl);
|
|
MethodSymbol ridee = cast(MethodSymbol.class, rideeEl);
|
|
ClassSymbol origin = cast(ClassSymbol.class, typeEl);
|
|
|
|
return rider.name == ridee.name &&
|
|
|
|
// not reflexive as per JLS
|
|
rider != ridee &&
|
|
|
|
// we don't care if ridee is static, though that wouldn't
|
|
// compile
|
|
!rider.isStatic() &&
|
|
|
|
// Symbol.overrides assumes the following
|
|
ridee.isMemberOf(origin, types) &&
|
|
|
|
// check access and signatures; don't check return types
|
|
rider.overrides(ridee, origin, types, false);
|
|
}
|
|
|
|
public String getConstantExpression(Object value) {
|
|
return Constants.format(value);
|
|
}
|
|
|
|
/**
|
|
* Print a representation of the elements to the given writer in
|
|
* the specified order. The main purpose of this method is for
|
|
* diagnostics. The exact format of the output is <em>not</em>
|
|
* specified and is subject to change.
|
|
*
|
|
* @param w the writer to print the output to
|
|
* @param elements the elements to print
|
|
*/
|
|
public void printElements(java.io.Writer w, Element... elements) {
|
|
for (Element element : elements)
|
|
(new PrintingProcessor.PrintingElementVisitor(w, this)).visit(element).flush();
|
|
}
|
|
|
|
public Name getName(CharSequence cs) {
|
|
return names.fromString(cs.toString());
|
|
}
|
|
|
|
@Override
|
|
public boolean isFunctionalInterface(TypeElement element) {
|
|
if (element.getKind() != ElementKind.INTERFACE)
|
|
return false;
|
|
else {
|
|
TypeSymbol tsym = cast(TypeSymbol.class, element);
|
|
return types.isFunctionalInterface(tsym);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the tree node and compilation unit corresponding to this
|
|
* element, or null if they can't be found.
|
|
*/
|
|
private Pair<JCTree, JCCompilationUnit> getTreeAndTopLevel(Element e) {
|
|
Symbol sym = cast(Symbol.class, e);
|
|
Env<AttrContext> enterEnv = getEnterEnv(sym);
|
|
if (enterEnv == null)
|
|
return null;
|
|
JCTree tree = TreeInfo.declarationFor(sym, enterEnv.tree);
|
|
if (tree == null || enterEnv.toplevel == null)
|
|
return null;
|
|
return new Pair<JCTree,JCCompilationUnit>(tree, enterEnv.toplevel);
|
|
}
|
|
|
|
/**
|
|
* Returns the best approximation for the tree node and compilation unit
|
|
* corresponding to the given element, annotation and value.
|
|
* If the element is null, null is returned.
|
|
* If the annotation is null or cannot be found, the tree node and
|
|
* compilation unit for the element is returned.
|
|
* If the annotation value is null or cannot be found, the tree node and
|
|
* compilation unit for the annotation is returned.
|
|
*/
|
|
public Pair<JCTree, JCCompilationUnit> getTreeAndTopLevel(
|
|
Element e, AnnotationMirror a, AnnotationValue v) {
|
|
if (e == null)
|
|
return null;
|
|
|
|
Pair<JCTree, JCCompilationUnit> elemTreeTop = getTreeAndTopLevel(e);
|
|
if (elemTreeTop == null)
|
|
return null;
|
|
|
|
if (a == null)
|
|
return elemTreeTop;
|
|
|
|
JCTree annoTree = matchAnnoToTree(a, e, elemTreeTop.fst);
|
|
if (annoTree == null)
|
|
return elemTreeTop;
|
|
|
|
// 6388543: if v != null, we should search within annoTree to find
|
|
// the tree matching v. For now, we ignore v and return the tree of
|
|
// the annotation.
|
|
return new Pair<JCTree, JCCompilationUnit>(annoTree, elemTreeTop.snd);
|
|
}
|
|
|
|
/**
|
|
* Returns a symbol's enter environment, or null if it has none.
|
|
*/
|
|
private Env<AttrContext> getEnterEnv(Symbol sym) {
|
|
// Get enclosing class of sym, or sym itself if it is a class
|
|
// or package.
|
|
TypeSymbol ts = (sym.kind != Kinds.PCK)
|
|
? sym.enclClass()
|
|
: (PackageSymbol) sym;
|
|
return (ts != null)
|
|
? enter.getEnv(ts)
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* Returns an object cast to the specified type.
|
|
* @throws NullPointerException if the object is {@code null}
|
|
* @throws IllegalArgumentException if the object is of the wrong type
|
|
*/
|
|
private static <T> T cast(Class<T> clazz, Object o) {
|
|
if (! clazz.isInstance(o))
|
|
throw new IllegalArgumentException(o.toString());
|
|
return clazz.cast(o);
|
|
}
|
|
}
|