jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/code/Symbol.java@e5d3cd43c85e (annotated)

src/share/classes/com/sun/tools/javac/code/Symbol.java@e5d3cd43c85e (annotated)

src/share/classes/com/sun/tools/javac/code/Symbol.java

Sun, 20 Oct 2013 12:01:43 -0700

author: jjg
date: Sun, 20 Oct 2013 12:01:43 -0700
changeset 2149: e5d3cd43c85e
parent 2100: 1e7ad879f15e
child 2301: 27a3026256cd
permissions: -rw-r--r--

8025109: Better encapsulation for AnnotatedType
Reviewed-by: jjg
Contributed-by: wdietl@gmail.com

 /*
  * 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><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>
  */
 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<R, P> 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<R, P> v, P p) {
             return other.accept(v, p);
         }
         public <R, P> R accept(Symbol.Visitor<R, P> 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<R, P> 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<A> 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<R, P> 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<R, P> v, P p) {
             return v.visitPackage(this, p);
         }
         public <R, P> R accept(Symbol.Visitor<R, P> 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<A> 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<A> 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<R, P> v, P p) {
             return v.visitType(this, p);
         }
         public <R, P> R accept(Symbol.Visitor<R, P> 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<R, P> 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<R, P> 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<Symbol>() {
                 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<VarSymbol>();
                 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<R, P> v, P p) {
             return v.visitExecutable(this, p);
         }
         public <R, P> R accept(Symbol.Visitor<R, P> 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<R, P> 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&nbsp;&times;&nbsp;P&nbsp;&rarr;&nbsp;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);
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/code/Symbol.java@e5d3cd43c85e (annotated)

src/share/classes/com/sun/tools/javac/code/Symbol.java