/*

 * Copyright (c) 1999, 2014, 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.Scope.WriteableScope;

import com.sun.tools.javac.code.Type.*;

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.tree.JCTree.JCVariableDecl;

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.Scope.LookupKind.NON_RECURSIVE;

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 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 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 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 WriteableScope members() {

        return null;

    }

    /** A class is an inner class if it it has an enclosing instance class.

     */

    public boolean isInner() {

        return kind == TYP && 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);

        Assert.check(sym != null, "the result of hiddenInInternal() can't be null");

        /* If we find the current symbol then there is no symbol hiding it

         */

        return sym != this;

    }

    /** This method looks in the supertypes graph that has the current class as the

     * initial node, till it finds the current symbol or another symbol that hides it.

     * If the current class has more than one supertype (extends one class and

     * implements one or more interfaces) then null can be returned, meaning that

     * a wrong path in the supertypes graph was selected. Null can only be returned

     * as a temporary value, as a result of the recursive call.

     */

    private Symbol hiddenInInternal(ClassSymbol currentClass, Types types) {

        if (currentClass == owner) {

            return this;

        }

        for (Symbol sym : currentClass.members().getSymbolsByName(name)) {

            if (sym.kind == kind &&

                    (kind != MTH ||

                    (sym.flags() & STATIC) != 0 &&

                    types.isSubSignature(sym.type, type))) {

                return sym;

            }

        }

        Symbol hiddenSym = null;

        for (Type st : types.interfaces(currentClass.type)

                .prepend(types.supertype(currentClass.type))) {

            if (st != null && (st.hasTag(CLASS))) {

                Symbol sym = hiddenInInternal((ClassSymbol)st.tsym, types);

                if (sym == this) {

                    return this;

                } else if (sym != null) {

                    hiddenSym = sym;

                }

            }

        }

        return hiddenSym;

    }

    /** Is this symbol inherited into a given class?