|
|
The Symbol.java Java example source code
/*
* Copyright (c) 1999, 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.code;
import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.util.Set;
import java.util.concurrent.Callable;
import javax.lang.model.element.*;
import javax.tools.JavaFileObject;
import com.sun.tools.javac.code.Type.*;
import com.sun.tools.javac.comp.Annotate;
import com.sun.tools.javac.comp.Attr;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Env;
import com.sun.tools.javac.jvm.*;
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.util.Name;
import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.Kinds.*;
import static com.sun.tools.javac.code.TypeTag.CLASS;
import static com.sun.tools.javac.code.TypeTag.FORALL;
import static com.sun.tools.javac.code.TypeTag.TYPEVAR;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
/** Root class for Java symbols. It contains subclasses
* for specific sorts of symbols, such as variables, methods and operators,
* types, packages. Each subclass is represented as a static inner class
* inside Symbol.
*
* <p>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>
*/
public abstract class Symbol extends AnnoConstruct implements Element {
/** The kind of this symbol.
* @see Kinds
*/
public int kind;
/** The flags of this symbol.
*/
public long flags_field;
/** An accessor method for the flags of this symbol.
* Flags of class symbols should be accessed through the accessor
* method to make sure that the class symbol is loaded.
*/
public long flags() { return flags_field; }
/** The name of this symbol in Utf8 representation.
*/
public Name name;
/** The type of this symbol.
*/
public Type type;
/** The owner of this symbol.
*/
public Symbol owner;
/** The completer of this symbol.
*/
public Completer completer;
/** A cache for the type erasure of this symbol.
*/
public Type erasure_field;
// <editor-fold defaultstate="collapsed" desc="annotations">
/** The attributes of this symbol are contained in this
* SymbolMetadata. The SymbolMetadata instance is NOT immutable.
*/
protected SymbolMetadata metadata;
/** An accessor method for the attributes of this symbol.
* Attributes of class symbols should be accessed through the accessor
* method to make sure that the class symbol is loaded.
*/
public List<Attribute.Compound> getRawAttributes() {
return (metadata == null)
? List.<Attribute.Compound>nil()
: metadata.getDeclarationAttributes();
}
/** An accessor method for the type attributes of this symbol.
* Attributes of class symbols should be accessed through the accessor
* method to make sure that the class symbol is loaded.
*/
public List<Attribute.TypeCompound> getRawTypeAttributes() {
return (metadata == null)
? List.<Attribute.TypeCompound>nil()
: metadata.getTypeAttributes();
}
/** Fetch a particular annotation from a symbol. */
public Attribute.Compound attribute(Symbol anno) {
for (Attribute.Compound a : getRawAttributes()) {
if (a.type.tsym == anno) return a;
}
return null;
}
public boolean annotationsPendingCompletion() {
return metadata == null ? false : metadata.pendingCompletion();
}
public void appendAttributes(List<Attribute.Compound> l) {
if (l.nonEmpty()) {
initedMetadata().append(l);
}
}
public void appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
if (l.nonEmpty()) {
initedMetadata().appendClassInitTypeAttributes(l);
}
}
public void appendInitTypeAttributes(List<Attribute.TypeCompound> l) {
if (l.nonEmpty()) {
initedMetadata().appendInitTypeAttributes(l);
}
}
public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.TypeCompound> ctx) {
initedMetadata().appendTypeAttributesWithCompletion(ctx);
}
public void appendUniqueTypeAttributes(List<Attribute.TypeCompound> l) {
if (l.nonEmpty()) {
initedMetadata().appendUniqueTypes(l);
}
}
public List<Attribute.TypeCompound> getClassInitTypeAttributes() {
return (metadata == null)
? List.<Attribute.TypeCompound>nil()
: metadata.getClassInitTypeAttributes();
}
public List<Attribute.TypeCompound> getInitTypeAttributes() {
return (metadata == null)
? List.<Attribute.TypeCompound>nil()
: metadata.getInitTypeAttributes();
}
public List<Attribute.Compound> getDeclarationAttributes() {
return (metadata == null)
? List.<Attribute.Compound>nil()
: metadata.getDeclarationAttributes();
}
public boolean hasAnnotations() {
return (metadata != null && !metadata.isEmpty());
}
public boolean hasTypeAnnotations() {
return (metadata != null && !metadata.isTypesEmpty());
}
public void prependAttributes(List<Attribute.Compound> l) {
if (l.nonEmpty()) {
initedMetadata().prepend(l);
}
}
public void resetAnnotations() {
initedMetadata().reset();
}
public void setAttributes(Symbol other) {
if (metadata != null || other.metadata != null) {
initedMetadata().setAttributes(other.metadata);
}
}
public void setDeclarationAttributes(List<Attribute.Compound> a) {
if (metadata != null || a.nonEmpty()) {
initedMetadata().setDeclarationAttributes(a);
}
}
public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {
initedMetadata().setDeclarationAttributesWithCompletion(ctx);
}
public void setTypeAttributes(List<Attribute.TypeCompound> a) {
if (metadata != null || a.nonEmpty()) {
if (metadata == null)
metadata = new SymbolMetadata(this);
metadata.setTypeAttributes(a);
}
}
private SymbolMetadata initedMetadata() {
if (metadata == null)
metadata = new SymbolMetadata(this);
return metadata;
}
/** This method is intended for debugging only. */
public SymbolMetadata getMetadata() {
return metadata;
}
// </editor-fold>
/** Construct a symbol with given kind, flags, name, type and owner.
*/
public Symbol(int kind, long flags, Name name, Type type, Symbol owner) {
this.kind = kind;
this.flags_field = flags;
this.type = type;
this.owner = owner;
this.completer = null;
this.erasure_field = null;
this.name = name;
}
/** Clone this symbol with new owner.
* Legal only for fields and methods.
*/
public Symbol clone(Symbol newOwner) {
throw new AssertionError();
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitSymbol(this, p);
}
/** The Java source which this symbol represents.
* A description of this symbol; overrides Object.
*/
public String toString() {
return name.toString();
}
/** A Java source description of the location of this symbol; used for
* error reporting.
*
* @return null if the symbol is a package or a toplevel class defined in
* the default package; otherwise, the owner symbol is returned
*/
public Symbol location() {
if (owner.name == null || (owner.name.isEmpty() &&
(owner.flags() & BLOCK) == 0 && owner.kind != PCK && owner.kind != TYP)) {
return null;
}
return owner;
}
public Symbol location(Type site, Types types) {
if (owner.name == null || owner.name.isEmpty()) {
return location();
}
if (owner.type.hasTag(CLASS)) {
Type ownertype = types.asOuterSuper(site, owner);
if (ownertype != null) return ownertype.tsym;
}
return owner;
}
public Symbol baseSymbol() {
return this;
}
/** The symbol's erased type.
*/
public Type erasure(Types types) {
if (erasure_field == null)
erasure_field = types.erasure(type);
return erasure_field;
}
/** The external type of a symbol. This is the symbol's erased type
* except for constructors of inner classes which get the enclosing
* instance class added as first argument.
*/
public Type externalType(Types types) {
Type t = erasure(types);
if (name == name.table.names.init && owner.hasOuterInstance()) {
Type outerThisType = types.erasure(owner.type.getEnclosingType());
return new MethodType(t.getParameterTypes().prepend(outerThisType),
t.getReturnType(),
t.getThrownTypes(),
t.tsym);
} else {
return t;
}
}
public boolean isDeprecated() {
return (flags_field & DEPRECATED) != 0;
}
public boolean isStatic() {
return
(flags() & STATIC) != 0 ||
(owner.flags() & INTERFACE) != 0 && kind != MTH &&
name != name.table.names._this;
}
public boolean isInterface() {
return (flags() & INTERFACE) != 0;
}
public boolean isPrivate() {
return (flags_field & Flags.AccessFlags) == PRIVATE;
}
public boolean isEnum() {
return (flags() & ENUM) != 0;
}
/** Is this symbol declared (directly or indirectly) local
* to a method or variable initializer?
* Also includes fields of inner classes which are in
* turn local to a method or variable initializer.
*/
public boolean isLocal() {
return
(owner.kind & (VAR | MTH)) != 0 ||
(owner.kind == TYP && owner.isLocal());
}
/** Has this symbol an empty name? This includes anonymous
* inner classes.
*/
public boolean isAnonymous() {
return name.isEmpty();
}
/** Is this symbol a constructor?
*/
public boolean isConstructor() {
return name == name.table.names.init;
}
/** The fully qualified name of this symbol.
* This is the same as the symbol's name except for class symbols,
* which are handled separately.
*/
public Name getQualifiedName() {
return name;
}
/** The fully qualified name of this symbol after converting to flat
* representation. This is the same as the symbol's name except for
* class symbols, which are handled separately.
*/
public Name flatName() {
return getQualifiedName();
}
/** If this is a class or package, its members, otherwise null.
*/
public Scope members() {
return null;
}
/** A class is an inner class if it it has an enclosing instance class.
*/
public boolean isInner() {
return type.getEnclosingType().hasTag(CLASS);
}
/** An inner class has an outer instance if it is not an interface
* it has an enclosing instance class which might be referenced from the class.
* Nested classes can see instance members of their enclosing class.
* Their constructors carry an additional this$n parameter, inserted
* implicitly by the compiler.
*
* @see #isInner
*/
public boolean hasOuterInstance() {
return
type.getEnclosingType().hasTag(CLASS) && (flags() & (INTERFACE | NOOUTERTHIS)) == 0;
}
/** The closest enclosing class of this symbol's declaration.
*/
public ClassSymbol enclClass() {
Symbol c = this;
while (c != null &&
((c.kind & TYP) == 0 || !c.type.hasTag(CLASS))) {
c = c.owner;
}
return (ClassSymbol)c;
}
/** The outermost class which indirectly owns this symbol.
*/
public ClassSymbol outermostClass() {
Symbol sym = this;
Symbol prev = null;
while (sym.kind != PCK) {
prev = sym;
sym = sym.owner;
}
return (ClassSymbol) prev;
}
/** The package which indirectly owns this symbol.
*/
public PackageSymbol packge() {
Symbol sym = this;
while (sym.kind != PCK) {
sym = sym.owner;
}
return (PackageSymbol) sym;
}
/** Is this symbol a subclass of `base'? Only defined for ClassSymbols.
*/
public boolean isSubClass(Symbol base, Types types) {
throw new AssertionError("isSubClass " + this);
}
/** Fully check membership: hierarchy, protection, and hiding.
* Does not exclude methods not inherited due to overriding.
*/
public boolean isMemberOf(TypeSymbol clazz, Types types) {
return
owner == clazz ||
clazz.isSubClass(owner, types) &&
isInheritedIn(clazz, types) &&
!hiddenIn((ClassSymbol)clazz, types);
}
/** Is this symbol the same as or enclosed by the given class? */
public boolean isEnclosedBy(ClassSymbol clazz) {
for (Symbol sym = this; sym.kind != PCK; sym = sym.owner)
if (sym == clazz) return true;
return false;
}
private boolean hiddenIn(ClassSymbol clazz, Types types) {
Symbol sym = hiddenInInternal(clazz, types);
return sym != null && sym != this;
}
private Symbol hiddenInInternal(ClassSymbol c, Types types) {
Scope.Entry e = c.members().lookup(name);
while (e.scope != null) {
if (e.sym.kind == kind &&
(kind != MTH ||
(e.sym.flags() & STATIC) != 0 &&
types.isSubSignature(e.sym.type, type))) {
return e.sym;
}
e = e.next();
}
List<Symbol> hiddenSyms = List.nil();
for (Type st : types.interfaces(c.type).prepend(types.supertype(c.type))) {
if (st != null && (st.hasTag(CLASS))) {
Symbol sym = hiddenInInternal((ClassSymbol)st.tsym, types);
if (sym != null) {
hiddenSyms = hiddenSyms.prepend(hiddenInInternal((ClassSymbol)st.tsym, types));
}
}
}
return hiddenSyms.contains(this) ?
this :
(hiddenSyms.isEmpty() ? null : hiddenSyms.head);
}
/** Is this symbol inherited into a given class?
* PRE: If symbol's owner is a interface,
* it is already assumed that the interface is a superinterface
* of given class.
* @param clazz The class for which we want to establish membership.
* This must be a subclass of the member's owner.
*/
public boolean isInheritedIn(Symbol clazz, Types types) {
switch ((int)(flags_field & Flags.AccessFlags)) {
default: // error recovery
case PUBLIC:
return true;
case PRIVATE:
return this.owner == clazz;
case PROTECTED:
// we model interfaces as extending Object
return (clazz.flags() & INTERFACE) == 0;
case 0:
PackageSymbol thisPackage = this.packge();
for (Symbol sup = clazz;
sup != null && sup != this.owner;
sup = types.supertype(sup.type).tsym) {
while (sup.type.hasTag(TYPEVAR))
sup = sup.type.getUpperBound().tsym;
if (sup.type.isErroneous())
return true; // error recovery
if ((sup.flags() & COMPOUND) != 0)
continue;
if (sup.packge() != thisPackage)
return false;
}
return (clazz.flags() & INTERFACE) == 0;
}
}
/** The (variable or method) symbol seen as a member of given
* class type`site' (this might change the symbol's type).
* This is used exclusively for producing diagnostics.
*/
public Symbol asMemberOf(Type site, Types types) {
throw new AssertionError();
}
/** Does this method symbol override `other' symbol, when both are seen as
* members of class `origin'? It is assumed that _other is a member
* of origin.
*
* It is assumed that both symbols have the same name. The static
* modifier is ignored for this test.
*
* See JLS 8.4.6.1 (without transitivity) and 8.4.6.4
*/
public boolean overrides(Symbol _other, TypeSymbol origin, Types types, boolean checkResult) {
return false;
}
/** Complete the elaboration of this symbol's definition.
*/
public void complete() throws CompletionFailure {
if (completer != null) {
Completer c = completer;
completer = null;
c.complete(this);
}
}
/** True if the symbol represents an entity that exists.
*/
public boolean exists() {
return true;
}
public Type asType() {
return type;
}
public Symbol getEnclosingElement() {
return owner;
}
public ElementKind getKind() {
return ElementKind.OTHER; // most unkind
}
public Set<Modifier> getModifiers() {
return Flags.asModifierSet(flags());
}
public Name getSimpleName() {
return name;
}
/**
* This is the implementation for {@code
* javax.lang.model.element.Element.getAnnotationMirrors()}.
*/
@Override
public List<Attribute.Compound> getAnnotationMirrors() {
return getRawAttributes();
}
// TODO: getEnclosedElements should return a javac List, fix in FilteredMemberList
public java.util.List<Symbol> getEnclosedElements() {
return List.nil();
}
public List<TypeVariableSymbol> getTypeParameters() {
ListBuffer<TypeVariableSymbol> l = new ListBuffer<>();
for (Type t : type.getTypeArguments()) {
Assert.check(t.tsym.getKind() == ElementKind.TYPE_PARAMETER);
l.append((TypeVariableSymbol)t.tsym);
}
return l.toList();
}
public static class DelegatedSymbol<T extends Symbol> extends Symbol {
protected T other;
public DelegatedSymbol(T other) {
super(other.kind, other.flags_field, other.name, other.type, other.owner);
this.other = other;
}
public String toString() { return other.toString(); }
public Symbol location() { return other.location(); }
public Symbol location(Type site, Types types) { return other.location(site, types); }
public Symbol baseSymbol() { return other; }
public Type erasure(Types types) { return other.erasure(types); }
public Type externalType(Types types) { return other.externalType(types); }
public boolean isLocal() { return other.isLocal(); }
public boolean isConstructor() { return other.isConstructor(); }
public Name getQualifiedName() { return other.getQualifiedName(); }
public Name flatName() { return other.flatName(); }
public Scope members() { return other.members(); }
public boolean isInner() { return other.isInner(); }
public boolean hasOuterInstance() { return other.hasOuterInstance(); }
public ClassSymbol enclClass() { return other.enclClass(); }
public ClassSymbol outermostClass() { return other.outermostClass(); }
public PackageSymbol packge() { return other.packge(); }
public boolean isSubClass(Symbol base, Types types) { return other.isSubClass(base, types); }
public boolean isMemberOf(TypeSymbol clazz, Types types) { return other.isMemberOf(clazz, types); }
public boolean isEnclosedBy(ClassSymbol clazz) { return other.isEnclosedBy(clazz); }
public boolean isInheritedIn(Symbol clazz, Types types) { return other.isInheritedIn(clazz, types); }
public Symbol asMemberOf(Type site, Types types) { return other.asMemberOf(site, types); }
public void complete() throws CompletionFailure { other.complete(); }
public <R, P> R accept(ElementVisitor v, P p) {
return other.accept(v, p);
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitSymbol(other, p);
}
public T getUnderlyingSymbol() {
return other;
}
}
/** A base class for Symbols representing types.
*/
public static abstract class TypeSymbol extends Symbol {
public TypeSymbol(int kind, long flags, Name name, Type type, Symbol owner) {
super(kind, flags, name, type, owner);
}
/** form a fully qualified name from a name and an owner
*/
static public Name formFullName(Name name, Symbol owner) {
if (owner == null) return name;
if (((owner.kind != ERR)) &&
((owner.kind & (VAR | MTH)) != 0
|| (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
)) return name;
Name prefix = owner.getQualifiedName();
if (prefix == null || prefix == prefix.table.names.empty)
return name;
else return prefix.append('.', name);
}
/** form a fully qualified name from a name and an owner, after
* converting to flat representation
*/
static public Name formFlatName(Name name, Symbol owner) {
if (owner == null ||
(owner.kind & (VAR | MTH)) != 0
|| (owner.kind == TYP && owner.type.hasTag(TYPEVAR))
) return name;
char sep = owner.kind == TYP ? '$' : '.';
Name prefix = owner.flatName();
if (prefix == null || prefix == prefix.table.names.empty)
return name;
else return prefix.append(sep, name);
}
/**
* A total ordering between type symbols that refines the
* class inheritance graph.
*
* Typevariables always precede other kinds of symbols.
*/
public final boolean precedes(TypeSymbol that, Types types) {
if (this == that)
return false;
if (type.hasTag(that.type.getTag())) {
if (type.hasTag(CLASS)) {
return
types.rank(that.type) < types.rank(this.type) ||
types.rank(that.type) == types.rank(this.type) &&
that.getQualifiedName().compareTo(this.getQualifiedName()) < 0;
} else if (type.hasTag(TYPEVAR)) {
return types.isSubtype(this.type, that.type);
}
}
return type.hasTag(TYPEVAR);
}
@Override
public java.util.List<Symbol> getEnclosedElements() {
List<Symbol> list = List.nil();
if (kind == TYP && type.hasTag(TYPEVAR)) {
return list;
}
for (Scope.Entry e = members().elems; e != null; e = e.sibling) {
if (e.sym != null && (e.sym.flags() & SYNTHETIC) == 0 && e.sym.owner == this)
list = list.prepend(e.sym);
}
return list;
}
@Override
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitTypeSymbol(this, p);
}
}
/**
* Type variables are represented by instances of this class.
*/
public static class TypeVariableSymbol
extends TypeSymbol implements TypeParameterElement {
public TypeVariableSymbol(long flags, Name name, Type type, Symbol owner) {
super(TYP, flags, name, type, owner);
}
public ElementKind getKind() {
return ElementKind.TYPE_PARAMETER;
}
@Override
public Symbol getGenericElement() {
return owner;
}
public List<Type> getBounds() {
TypeVar t = (TypeVar)type;
Type bound = t.getUpperBound();
if (!bound.isCompound())
return List.of(bound);
ClassType ct = (ClassType)bound;
if (!ct.tsym.erasure_field.isInterface()) {
return ct.interfaces_field.prepend(ct.supertype_field);
} else {
// No superclass was given in bounds.
// In this case, supertype is Object, erasure is first interface.
return ct.interfaces_field;
}
}
@Override
public List<Attribute.Compound> getAnnotationMirrors() {
return onlyTypeVariableAnnotations(owner.getRawTypeAttributes());
}
private List<Attribute.Compound> onlyTypeVariableAnnotations(
List<Attribute.TypeCompound> candidates) {
// Declaration annotations on TypeParameters are stored in type attributes
List<Attribute.Compound> res = List.nil();
for (Attribute.TypeCompound a : candidates) {
if (a.position.type == TargetType.CLASS_TYPE_PARAMETER ||
a.position.type == TargetType.METHOD_TYPE_PARAMETER)
res = res.prepend(a);
}
return res = res.reverse();
}
// Helper to getAnnotation[s]
@Override
public <A extends Annotation> Attribute.Compound getAttribute(Class annoType) {
String name = annoType.getName();
// Declaration annotations on type variables are stored in type attributes
// on the owner of the TypeVariableSymbol
List<Attribute.TypeCompound> candidates = owner.getRawTypeAttributes();
for (Attribute.TypeCompound anno : candidates)
if (anno.position.type == TargetType.CLASS_TYPE_PARAMETER ||
anno.position.type == TargetType.METHOD_TYPE_PARAMETER)
if (name.contentEquals(anno.type.tsym.flatName()))
return anno;
return null;
}
@Override
public <R, P> R accept(ElementVisitor v, P p) {
return v.visitTypeParameter(this, p);
}
}
/** A class for package symbols
*/
public static class PackageSymbol extends TypeSymbol
implements PackageElement {
public Scope members_field;
public Name fullname;
public ClassSymbol package_info; // see bug 6443073
public PackageSymbol(Name name, Type type, Symbol owner) {
super(PCK, 0, name, type, owner);
this.members_field = null;
this.fullname = formFullName(name, owner);
}
public PackageSymbol(Name name, Symbol owner) {
this(name, null, owner);
this.type = new PackageType(this);
}
public String toString() {
return fullname.toString();
}
public Name getQualifiedName() {
return fullname;
}
public boolean isUnnamed() {
return name.isEmpty() && owner != null;
}
public Scope members() {
if (completer != null) complete();
return members_field;
}
public long flags() {
if (completer != null) complete();
return flags_field;
}
@Override
public List<Attribute.Compound> getRawAttributes() {
if (completer != null) complete();
if (package_info != null && package_info.completer != null) {
package_info.complete();
mergeAttributes();
}
return super.getRawAttributes();
}
private void mergeAttributes() {
if (metadata == null &&
package_info.metadata != null) {
metadata = new SymbolMetadata(this);
metadata.setAttributes(package_info.metadata);
}
}
/** A package "exists" if a type or package that exists has
* been seen within it.
*/
public boolean exists() {
return (flags_field & EXISTS) != 0;
}
public ElementKind getKind() {
return ElementKind.PACKAGE;
}
public Symbol getEnclosingElement() {
return null;
}
public <R, P> R accept(ElementVisitor v, P p) {
return v.visitPackage(this, p);
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitPackageSymbol(this, p);
}
}
/** A class for class symbols
*/
public static class ClassSymbol extends TypeSymbol implements TypeElement {
/** a scope for all class members; variables, methods and inner classes
* type parameters are not part of this scope
*/
public Scope members_field;
/** the fully qualified name of the class, i.e. pck.outer.inner.
* null for anonymous classes
*/
public Name fullname;
/** the fully qualified name of the class after converting to flat
* representation, i.e. pck.outer$inner,
* set externally for local and anonymous classes
*/
public Name flatname;
/** the sourcefile where the class came from
*/
public JavaFileObject sourcefile;
/** the classfile from where to load this class
* this will have extension .class or .java
*/
public JavaFileObject classfile;
/** the list of translated local classes (used for generating
* InnerClasses attribute)
*/
public List<ClassSymbol> trans_local;
/** the constant pool of the class
*/
public Pool pool;
public ClassSymbol(long flags, Name name, Type type, Symbol owner) {
super(TYP, flags, name, type, owner);
this.members_field = null;
this.fullname = formFullName(name, owner);
this.flatname = formFlatName(name, owner);
this.sourcefile = null;
this.classfile = null;
this.pool = null;
}
public ClassSymbol(long flags, Name name, Symbol owner) {
this(
flags,
name,
new ClassType(Type.noType, null, null),
owner);
this.type.tsym = this;
}
/** The Java source which this symbol represents.
*/
public String toString() {
return className();
}
public long flags() {
if (completer != null) complete();
return flags_field;
}
public Scope members() {
if (completer != null) complete();
return members_field;
}
@Override
public List<Attribute.Compound> getRawAttributes() {
if (completer != null) complete();
return super.getRawAttributes();
}
@Override
public List<Attribute.TypeCompound> getRawTypeAttributes() {
if (completer != null) complete();
return super.getRawTypeAttributes();
}
public Type erasure(Types types) {
if (erasure_field == null)
erasure_field = new ClassType(types.erasure(type.getEnclosingType()),
List.<Type>nil(), this);
return erasure_field;
}
public String className() {
if (name.isEmpty())
return
Log.getLocalizedString("anonymous.class", flatname);
else
return fullname.toString();
}
public Name getQualifiedName() {
return fullname;
}
public Name flatName() {
return flatname;
}
public boolean isSubClass(Symbol base, Types types) {
if (this == base) {
return true;
} else if ((base.flags() & INTERFACE) != 0) {
for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
for (List<Type> is = types.interfaces(t);
is.nonEmpty();
is = is.tail)
if (is.head.tsym.isSubClass(base, types)) return true;
} else {
for (Type t = type; t.hasTag(CLASS); t = types.supertype(t))
if (t.tsym == base) return true;
}
return false;
}
/** Complete the elaboration of this symbol's definition.
*/
public void complete() throws CompletionFailure {
try {
super.complete();
} catch (CompletionFailure ex) {
// quiet error recovery
flags_field |= (PUBLIC|STATIC);
this.type = new ErrorType(this, Type.noType);
throw ex;
}
}
public List<Type> getInterfaces() {
complete();
if (type instanceof ClassType) {
ClassType t = (ClassType)type;
if (t.interfaces_field == null) // FIXME: shouldn't be null
t.interfaces_field = List.nil();
if (t.all_interfaces_field != null)
return Type.getModelTypes(t.all_interfaces_field);
return t.interfaces_field;
} else {
return List.nil();
}
}
public Type getSuperclass() {
complete();
if (type instanceof ClassType) {
ClassType t = (ClassType)type;
if (t.supertype_field == null) // FIXME: shouldn't be null
t.supertype_field = Type.noType;
// An interface has no superclass; its supertype is Object.
return t.isInterface()
? Type.noType
: t.supertype_field.getModelType();
} else {
return Type.noType;
}
}
/**
* Returns the next class to search for inherited annotations or {@code null}
* if the next class can't be found.
*/
private ClassSymbol getSuperClassToSearchForAnnotations() {
Type sup = getSuperclass();
if (!sup.hasTag(CLASS) || sup.isErroneous())
return null;
return (ClassSymbol) sup.tsym;
}
@Override
protected <A extends Annotation> A[] getInheritedAnnotations(Class annoType) {
ClassSymbol sup = getSuperClassToSearchForAnnotations();
return sup == null ? super.getInheritedAnnotations(annoType)
: sup.getAnnotationsByType(annoType);
}
public ElementKind getKind() {
long flags = flags();
if ((flags & ANNOTATION) != 0)
return ElementKind.ANNOTATION_TYPE;
else if ((flags & INTERFACE) != 0)
return ElementKind.INTERFACE;
else if ((flags & ENUM) != 0)
return ElementKind.ENUM;
else
return ElementKind.CLASS;
}
@Override
public Set<Modifier> getModifiers() {
long flags = flags();
return Flags.asModifierSet(flags & ~DEFAULT);
}
public NestingKind getNestingKind() {
complete();
if (owner.kind == PCK)
return NestingKind.TOP_LEVEL;
else if (name.isEmpty())
return NestingKind.ANONYMOUS;
else if (owner.kind == MTH)
return NestingKind.LOCAL;
else
return NestingKind.MEMBER;
}
@Override
protected <A extends Annotation> Attribute.Compound getAttribute(final Class annoType) {
Attribute.Compound attrib = super.getAttribute(annoType);
boolean inherited = annoType.isAnnotationPresent(Inherited.class);
if (attrib != null || !inherited)
return attrib;
// Search supertypes
ClassSymbol superType = getSuperClassToSearchForAnnotations();
return superType == null ? null
: superType.getAttribute(annoType);
}
public <R, P> R accept(ElementVisitor v, P p) {
return v.visitType(this, p);
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitClassSymbol(this, p);
}
}
/** A class for variable symbols
*/
public static class VarSymbol extends Symbol implements VariableElement {
/** The variable's declaration position.
*/
public int pos = Position.NOPOS;
/** The variable's address. Used for different purposes during
* flow analysis, translation and code generation.
* Flow analysis:
* If this is a blank final or local variable, its sequence number.
* Translation:
* If this is a private field, its access number.
* Code generation:
* If this is a local variable, its logical slot number.
*/
public int adr = -1;
/** Construct a variable symbol, given its flags, name, type and owner.
*/
public VarSymbol(long flags, Name name, Type type, Symbol owner) {
super(VAR, flags, name, type, owner);
}
/** Clone this symbol with new owner.
*/
public VarSymbol clone(Symbol newOwner) {
VarSymbol v = new VarSymbol(flags_field, name, type, newOwner) {
@Override
public Symbol baseSymbol() {
return VarSymbol.this;
}
};
v.pos = pos;
v.adr = adr;
v.data = data;
// System.out.println("clone " + v + " in " + newOwner);//DEBUG
return v;
}
public String toString() {
return name.toString();
}
public Symbol asMemberOf(Type site, Types types) {
return new VarSymbol(flags_field, name, types.memberType(site, this), owner);
}
public ElementKind getKind() {
long flags = flags();
if ((flags & PARAMETER) != 0) {
if (isExceptionParameter())
return ElementKind.EXCEPTION_PARAMETER;
else
return ElementKind.PARAMETER;
} else if ((flags & ENUM) != 0) {
return ElementKind.ENUM_CONSTANT;
} else if (owner.kind == TYP || owner.kind == ERR) {
return ElementKind.FIELD;
} else if (isResourceVariable()) {
return ElementKind.RESOURCE_VARIABLE;
} else {
return ElementKind.LOCAL_VARIABLE;
}
}
public <R, P> R accept(ElementVisitor v, P p) {
return v.visitVariable(this, p);
}
public Object getConstantValue() { // Mirror API
return Constants.decode(getConstValue(), type);
}
public void setLazyConstValue(final Env<AttrContext> env,
final Attr attr,
final JCVariableDecl variable)
{
setData(new Callable<Object>() {
public Object call() {
return attr.attribLazyConstantValue(env, variable, type);
}
});
}
/**
* The variable's constant value, if this is a constant.
* Before the constant value is evaluated, it points to an
* initializer environment. If this is not a constant, it can
* be used for other stuff.
*/
private Object data;
public boolean isExceptionParameter() {
return data == ElementKind.EXCEPTION_PARAMETER;
}
public boolean isResourceVariable() {
return data == ElementKind.RESOURCE_VARIABLE;
}
public Object getConstValue() {
// TODO: Consider if getConstValue and getConstantValue can be collapsed
if (data == ElementKind.EXCEPTION_PARAMETER ||
data == ElementKind.RESOURCE_VARIABLE) {
return null;
} else if (data instanceof Callable<?>) {
// In this case, this is a final variable, with an as
// yet unevaluated initializer.
Callable<?> eval = (Callable)data;
data = null; // to make sure we don't evaluate this twice.
try {
data = eval.call();
} catch (Exception ex) {
throw new AssertionError(ex);
}
}
return data;
}
public void setData(Object data) {
Assert.check(!(data instanceof Env<?>), this);
this.data = data;
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitVarSymbol(this, p);
}
}
/** A class for method symbols.
*/
public static class MethodSymbol extends Symbol implements ExecutableElement {
/** The code of the method. */
public Code code = null;
/** The extra (synthetic/mandated) parameters of the method. */
public List<VarSymbol> extraParams = List.nil();
/** The captured local variables in an anonymous class */
public List<VarSymbol> capturedLocals = List.nil();
/** The parameters of the method. */
public List<VarSymbol> params = null;
/** The names of the parameters */
public List<Name> savedParameterNames;
/** For an attribute field accessor, its default value if any.
* The value is null if none appeared in the method
* declaration.
*/
public Attribute defaultValue = null;
/** Construct a method symbol, given its flags, name, type and owner.
*/
public MethodSymbol(long flags, Name name, Type type, Symbol owner) {
super(MTH, flags, name, type, owner);
if (owner.type.hasTag(TYPEVAR)) Assert.error(owner + "." + name);
}
/** Clone this symbol with new owner.
*/
public MethodSymbol clone(Symbol newOwner) {
MethodSymbol m = new MethodSymbol(flags_field, name, type, newOwner) {
@Override
public Symbol baseSymbol() {
return MethodSymbol.this;
}
};
m.code = code;
return m;
}
@Override
public Set<Modifier> getModifiers() {
long flags = flags();
return Flags.asModifierSet((flags & DEFAULT) != 0 ? flags & ~ABSTRACT : flags);
}
/** The Java source which this symbol represents.
*/
public String toString() {
if ((flags() & BLOCK) != 0) {
return owner.name.toString();
} else {
String s = (name == name.table.names.init)
? owner.name.toString()
: name.toString();
if (type != null) {
if (type.hasTag(FORALL))
s = "<" + ((ForAll)type).getTypeArguments() + ">" + s;
s += "(" + type.argtypes((flags() & VARARGS) != 0) + ")";
}
return s;
}
}
public boolean isDynamic() {
return false;
}
/** find a symbol that this (proxy method) symbol implements.
* @param c The class whose members are searched for
* implementations
*/
public Symbol implemented(TypeSymbol c, Types types) {
Symbol impl = null;
for (List<Type> is = types.interfaces(c.type);
impl == null && is.nonEmpty();
is = is.tail) {
TypeSymbol i = is.head.tsym;
impl = implementedIn(i, types);
if (impl == null)
impl = implemented(i, types);
}
return impl;
}
public Symbol implementedIn(TypeSymbol c, Types types) {
Symbol impl = null;
for (Scope.Entry e = c.members().lookup(name);
impl == null && e.scope != null;
e = e.next()) {
if (this.overrides(e.sym, (TypeSymbol)owner, types, true) &&
// FIXME: I suspect the following requires a
// subst() for a parametric return type.
types.isSameType(type.getReturnType(),
types.memberType(owner.type, e.sym).getReturnType())) {
impl = e.sym;
}
}
return impl;
}
/** Will the erasure of this method be considered by the VM to
* override the erasure of the other when seen from class `origin'?
*/
public boolean binaryOverrides(Symbol _other, TypeSymbol origin, Types types) {
if (isConstructor() || _other.kind != MTH) return false;
if (this == _other) return true;
MethodSymbol other = (MethodSymbol)_other;
// check for a direct implementation
if (other.isOverridableIn((TypeSymbol)owner) &&
types.asSuper(owner.type, other.owner) != null &&
types.isSameType(erasure(types), other.erasure(types)))
return true;
// check for an inherited implementation
return
(flags() & ABSTRACT) == 0 &&
other.isOverridableIn(origin) &&
this.isMemberOf(origin, types) &&
types.isSameType(erasure(types), other.erasure(types));
}
/** The implementation of this (abstract) symbol in class origin,
* from the VM's point of view, null if method does not have an
* implementation in class.
* @param origin The class of which the implementation is a member.
*/
public MethodSymbol binaryImplementation(ClassSymbol origin, Types types) {
for (TypeSymbol c = origin; c != null; c = types.supertype(c.type).tsym) {
for (Scope.Entry e = c.members().lookup(name);
e.scope != null;
e = e.next()) {
if (e.sym.kind == MTH &&
((MethodSymbol)e.sym).binaryOverrides(this, origin, types))
return (MethodSymbol)e.sym;
}
}
return null;
}
/** Does this symbol override `other' symbol, when both are seen as
* members of class `origin'? It is assumed that _other is a member
* of origin.
*
* It is assumed that both symbols have the same name. The static
* modifier is ignored for this test.
*
* See JLS 8.4.6.1 (without transitivity) and 8.4.6.4
*/
public boolean overrides(Symbol _other, TypeSymbol origin, Types types, boolean checkResult) {
if (isConstructor() || _other.kind != MTH) return false;
if (this == _other) return true;
MethodSymbol other = (MethodSymbol)_other;
// check for a direct implementation
if (other.isOverridableIn((TypeSymbol)owner) &&
types.asSuper(owner.type, other.owner) != null) {
Type mt = types.memberType(owner.type, this);
Type ot = types.memberType(owner.type, other);
if (types.isSubSignature(mt, ot)) {
if (!checkResult)
return true;
if (types.returnTypeSubstitutable(mt, ot))
return true;
}
}
// check for an inherited implementation
if ((flags() & ABSTRACT) != 0 ||
((other.flags() & ABSTRACT) == 0 && (other.flags() & DEFAULT) == 0) ||
!other.isOverridableIn(origin) ||
!this.isMemberOf(origin, types))
return false;
// assert types.asSuper(origin.type, other.owner) != null;
Type mt = types.memberType(origin.type, this);
Type ot = types.memberType(origin.type, other);
return
types.isSubSignature(mt, ot) &&
(!checkResult || types.resultSubtype(mt, ot, types.noWarnings));
}
private boolean isOverridableIn(TypeSymbol origin) {
// JLS 8.4.6.1
switch ((int)(flags_field & Flags.AccessFlags)) {
case Flags.PRIVATE:
return false;
case Flags.PUBLIC:
return !this.owner.isInterface() ||
(flags_field & STATIC) == 0;
case Flags.PROTECTED:
return (origin.flags() & INTERFACE) == 0;
case 0:
// for package private: can only override in the same
// package
return
this.packge() == origin.packge() &&
(origin.flags() & INTERFACE) == 0;
default:
return false;
}
}
@Override
public boolean isInheritedIn(Symbol clazz, Types types) {
switch ((int)(flags_field & Flags.AccessFlags)) {
case PUBLIC:
return !this.owner.isInterface() ||
clazz == owner ||
(flags_field & STATIC) == 0;
default:
return super.isInheritedIn(clazz, types);
}
}
/** The implementation of this (abstract) symbol in class origin;
* null if none exists. Synthetic methods are not considered
* as possible implementations.
*/
public MethodSymbol implementation(TypeSymbol origin, Types types, boolean checkResult) {
return implementation(origin, types, checkResult, implementation_filter);
}
// where
public static final Filter<Symbol> implementation_filter = new Filter() {
public boolean accepts(Symbol s) {
return s.kind == Kinds.MTH &&
(s.flags() & SYNTHETIC) == 0;
}
};
public MethodSymbol implementation(TypeSymbol origin, Types types, boolean checkResult, Filter<Symbol> implFilter) {
MethodSymbol res = types.implementation(this, origin, checkResult, implFilter);
if (res != null)
return res;
// if origin is derived from a raw type, we might have missed
// an implementation because we do not know enough about instantiations.
// in this case continue with the supertype as origin.
if (types.isDerivedRaw(origin.type) && !origin.isInterface())
return implementation(types.supertype(origin.type).tsym, types, checkResult);
else
return null;
}
public List<VarSymbol> params() {
owner.complete();
if (params == null) {
// If ClassReader.saveParameterNames has been set true, then
// savedParameterNames will be set to a list of names that
// matches the types in type.getParameterTypes(). If any names
// were not found in the class file, those names in the list will
// be set to the empty name.
// If ClassReader.saveParameterNames has been set false, then
// savedParameterNames will be null.
List<Name> paramNames = savedParameterNames;
savedParameterNames = null;
// discard the provided names if the list of names is the wrong size.
if (paramNames == null || paramNames.size() != type.getParameterTypes().size()) {
paramNames = List.nil();
}
ListBuffer<VarSymbol> buf = new ListBuffer();
List<Name> remaining = paramNames;
// assert: remaining and paramNames are both empty or both
// have same cardinality as type.getParameterTypes()
int i = 0;
for (Type t : type.getParameterTypes()) {
Name paramName;
if (remaining.isEmpty()) {
// no names for any parameters available
paramName = createArgName(i, paramNames);
} else {
paramName = remaining.head;
remaining = remaining.tail;
if (paramName.isEmpty()) {
// no name for this specific parameter
paramName = createArgName(i, paramNames);
}
}
buf.append(new VarSymbol(PARAMETER, paramName, t, this));
i++;
}
params = buf.toList();
}
return params;
}
// Create a name for the argument at position 'index' that is not in
// the exclude list. In normal use, either no names will have been
// provided, in which case the exclude list is empty, or all the names
// will have been provided, in which case this method will not be called.
private Name createArgName(int index, List<Name> exclude) {
String prefix = "arg";
while (true) {
Name argName = name.table.fromString(prefix + index);
if (!exclude.contains(argName))
return argName;
prefix += "$";
}
}
public Symbol asMemberOf(Type site, Types types) {
return new MethodSymbol(flags_field, name, types.memberType(site, this), owner);
}
public ElementKind getKind() {
if (name == name.table.names.init)
return ElementKind.CONSTRUCTOR;
else if (name == name.table.names.clinit)
return ElementKind.STATIC_INIT;
else if ((flags() & BLOCK) != 0)
return isStatic() ? ElementKind.STATIC_INIT : ElementKind.INSTANCE_INIT;
else
return ElementKind.METHOD;
}
public boolean isStaticOrInstanceInit() {
return getKind() == ElementKind.STATIC_INIT ||
getKind() == ElementKind.INSTANCE_INIT;
}
public Attribute getDefaultValue() {
return defaultValue;
}
public List<VarSymbol> getParameters() {
return params();
}
public boolean isVarArgs() {
return (flags() & VARARGS) != 0;
}
public boolean isDefault() {
return (flags() & DEFAULT) != 0;
}
public <R, P> R accept(ElementVisitor v, P p) {
return v.visitExecutable(this, p);
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitMethodSymbol(this, p);
}
public Type getReceiverType() {
return asType().getReceiverType();
}
public Type getReturnType() {
return asType().getReturnType();
}
public List<Type> getThrownTypes() {
return asType().getThrownTypes();
}
}
/** A class for invokedynamic method calls.
*/
public static class DynamicMethodSymbol extends MethodSymbol {
public Object[] staticArgs;
public Symbol bsm;
public int bsmKind;
public DynamicMethodSymbol(Name name, Symbol owner, int bsmKind, MethodSymbol bsm, Type type, Object[] staticArgs) {
super(0, name, type, owner);
this.bsm = bsm;
this.bsmKind = bsmKind;
this.staticArgs = staticArgs;
}
@Override
public boolean isDynamic() {
return true;
}
}
/** A class for predefined operators.
*/
public static class OperatorSymbol extends MethodSymbol {
public int opcode;
public OperatorSymbol(Name name, Type type, int opcode, Symbol owner) {
super(PUBLIC | STATIC, name, type, owner);
this.opcode = opcode;
}
public <R, P> R accept(Symbol.Visitor v, P p) {
return v.visitOperatorSymbol(this, p);
}
}
/** Symbol completer interface.
*/
public static interface Completer {
void complete(Symbol sym) throws CompletionFailure;
}
public static class CompletionFailure extends RuntimeException {
private static final long serialVersionUID = 0;
public Symbol sym;
/** A diagnostic object describing the failure
*/
public JCDiagnostic diag;
/** A localized string describing the failure.
* @deprecated Use {@code getDetail()} or {@code getMessage()}
*/
@Deprecated
public String errmsg;
public CompletionFailure(Symbol sym, String errmsg) {
this.sym = sym;
this.errmsg = errmsg;
// this.printStackTrace();//DEBUG
}
public CompletionFailure(Symbol sym, JCDiagnostic diag) {
this.sym = sym;
this.diag = diag;
// this.printStackTrace();//DEBUG
}
public JCDiagnostic getDiagnostic() {
return diag;
}
@Override
public String getMessage() {
if (diag != null)
return diag.getMessage(null);
else
return errmsg;
}
public Object getDetailValue() {
return (diag != null ? diag : errmsg);
}
@Override
public CompletionFailure initCause(Throwable cause) {
super.initCause(cause);
return this;
}
}
/**
* A visitor for symbols. A visitor is used to implement operations
* (or relations) on symbols. Most common operations on types are
* binary relations and this interface is designed for binary
* relations, that is, operations on the form
* Symbol × P → R.
* <!-- In plain text: Type x P -> R -->
*
* @param <R> the return type of the operation implemented by this
* visitor; use Void if no return type is needed.
* @param <P> the type of the second argument (the first being the
* symbol itself) of the operation implemented by this visitor; use
* Void if a second argument is not needed.
*/
public interface Visitor<R,P> {
R visitClassSymbol(ClassSymbol s, P arg);
R visitMethodSymbol(MethodSymbol s, P arg);
R visitPackageSymbol(PackageSymbol s, P arg);
R visitOperatorSymbol(OperatorSymbol s, P arg);
R visitVarSymbol(VarSymbol s, P arg);
R visitTypeSymbol(TypeSymbol s, P arg);
R visitSymbol(Symbol s, P arg);
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java Symbol.java source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project