/*

 * 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.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.model.*;

import com.sun.tools.javac.tree.JCTree;

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;

/** 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 implements Element {

    // public Throwable debug = new Throwable();

    /** 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

     * Annotations. The Annotations instance is NOT immutable.

     */

    protected Annotations annotations;

    /** 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 (annotations == null)

                ? List.<Attribute.Compound>nil()

                : annotations.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 (annotations == null)

                ? List.<Attribute.TypeCompound>nil()

                : annotations.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 annotations == null ? false : annotations.pendingCompletion();

    }

    public void appendAttributes(List<Attribute.Compound> l) {

        if (l.nonEmpty()) {

            initedAnnos().append(l);

        }

    }

    public void appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {

        if (l.nonEmpty()) {

            initedAnnos().appendClassInitTypeAttributes(l);

        }

    }

    public void appendInitTypeAttributes(List<Attribute.TypeCompound> l) {

        if (l.nonEmpty()) {

            initedAnnos().appendInitTypeAttributes(l);

        }

    }

    public void appendTypeAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.TypeCompound> ctx) {

        initedAnnos().appendTypeAttributesWithCompletion(ctx);

    }

    public void appendUniqueTypeAttributes(List<Attribute.TypeCompound> l) {

        if (l.nonEmpty()) {

            initedAnnos().appendUniqueTypes(l);

        }

    }

    public List<Attribute.TypeCompound> getClassInitTypeAttributes() {

        return (annotations == null)

                ? List.<Attribute.TypeCompound>nil()

                : annotations.getClassInitTypeAttributes();

    }

    public List<Attribute.TypeCompound> getInitTypeAttributes() {

        return (annotations == null)

                ? List.<Attribute.TypeCompound>nil()

                : annotations.getInitTypeAttributes();

    }

    public List<Attribute.Compound> getDeclarationAttributes() {

        return (annotations == null)

                ? List.<Attribute.Compound>nil()

                : annotations.getDeclarationAttributes();

    }

    public boolean hasAnnotations() {

        return (annotations != null && !annotations.isEmpty());

    }

    public boolean hasTypeAnnotations() {

        return (annotations != null && !annotations.isTypesEmpty());

    }

    public void prependAttributes(List<Attribute.Compound> l) {

        if (l.nonEmpty()) {

            initedAnnos().prepend(l);

        }

    }

    public void resetAnnotations() {

        initedAnnos().reset();

    }

    public void setAttributes(Symbol other) {

        if (annotations != null || other.annotations != null) {

            initedAnnos().setAttributes(other.annotations);

        }

    }

    public void setDeclarationAttributes(List<Attribute.Compound> a) {

        if (annotations != null || a.nonEmpty()) {

            initedAnnos().setDeclarationAttributes(a);

        }

    }

    public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {

        initedAnnos().setDeclarationAttributesWithCompletion(ctx);

    }

    public void setTypeAttributes(List<Attribute.TypeCompound> a) {

        if (annotations != null || a.nonEmpty()) {

            if (annotations == null)

                annotations = new Annotations(this);

            annotations.setTypeAttributes(a);

        }

    }

    private Annotations initedAnnos() {

        if (annotations == null)

            annotations = new Annotations(this);

        return annotations;

    }

    /** This method is intended for debugging only. */

    public Annotations getAnnotations() {

        return annotations;

    }

    // </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;

    }

    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) {

                    (kind != MTH ||

            }

        }

    }

    /** 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;