/*

 * 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 sun.tools.java;

import sun.tools.tree.Node;

import sun.tools.tree.Vset;

import sun.tools.tree.Expression;

import sun.tools.tree.Statement;

import sun.tools.tree.Context;

import sun.tools.asm.Assembler;

import java.io.PrintStream;

import java.util.Vector;

import java.util.Map;

import java.util.HashMap;

/**

 * This class defines a member of a Java class:

 * a variable, a method, or an inner class.

 *

 * WARNING: The contents of this source file are not part of any

 * supported API.  Code that depends on them does so at its own risk:

 * they are subject to change or removal without notice.

 */

public

class MemberDefinition implements Constants {

    protected long where;

    protected int modifiers;

    protected Type type;

    protected String documentation;

    protected IdentifierToken expIds[];

    protected ClassDeclaration exp[];

    protected Node value;

    protected ClassDefinition clazz;

    protected Identifier name;

    protected ClassDefinition innerClass;

    protected MemberDefinition nextMember;

    protected MemberDefinition nextMatch;

    protected MemberDefinition accessPeer;

    protected boolean superAccessMethod;

    /**

     * Constructor

     */

    public MemberDefinition(long where, ClassDefinition clazz, int modifiers,

                            Type type, Identifier name,

                            IdentifierToken expIds[], Node value) {

        if (expIds == null) {

            expIds = new IdentifierToken[0];

        }

        this.where = where;

        this.clazz = clazz;

        this.modifiers = modifiers;

        this.type = type;

        this.name = name;

        this.expIds = expIds;

        this.value = value;

    }

    /**

     * Constructor for an inner class.

     * Inner classes are represented as fields right along with

     * variables and methods for simplicity of data structure,

     * and to reflect properly the textual declaration order.

     * <p>

     * This constructor calls the generic constructor for this

     * class, extracting all necessary values from the innerClass.

     */

    public MemberDefinition(ClassDefinition innerClass) {

        this(innerClass.getWhere(),

             innerClass.getOuterClass(),

             innerClass.getModifiers(),

             innerClass.getType(),

             innerClass.getName().getFlatName().getName(),

             null, null);

        this.innerClass = innerClass;

    }

    /**

     * A cache of previously created proxy members.  Used to ensure

     * uniqueness of proxy objects.  See the makeProxyMember method

     * defined below.

     */

    static private Map<String,MemberDefinition> proxyCache;

    /**

     * Create a member which is externally the same as `field' but

     * is defined in class `classDef'.  This is used by code

     * in sun.tools.tree.(MethodExpression,FieldExpression) as

     * part of the fix for bug 4135692.

     *

     * Proxy members should not be added, ala addMember(), to classes.

     * They are merely "stand-ins" to produce modified MethodRef

     * constant pool entries during code generation.

     *

     * We keep a cache of previously created proxy members not to

     * save time or space, but to ensure uniqueness of the proxy

     * member for any (field,classDef) pair.  If these are not made

     * unique then we can end up generating duplicate MethodRef

     * constant pool entries during code generation.

     */

    public static MemberDefinition makeProxyMember(MemberDefinition field,

                                                   ClassDefinition classDef,

                                                   Environment env) {

        if (proxyCache == null) {

            proxyCache = new HashMap<>();

        }

        String key = field.toString() + "@" + classDef.toString();

        // System.out.println("Key is : " + key);

        MemberDefinition proxy = proxyCache.get(key);

        if (proxy != null)

            return proxy;

        proxy = new MemberDefinition(field.getWhere(), classDef,

                                     field.getModifiers(), field.getType(),

                                     field.getName(), field.getExceptionIds(),

                                     null);

        proxy.exp = field.getExceptions(env);

        proxyCache.put(key, proxy);

        return proxy;

    }

    /**

     * Get the position in the input

     */

    public final long getWhere() {

        return where;

    }

    /**

     * Get the class declaration

     */

    public final ClassDeclaration getClassDeclaration() {

        return clazz.getClassDeclaration();

    }

    /**

     * A stub.  Subclasses can do more checking.

     */

    public void resolveTypeStructure(Environment env) {

    }

    /**

     * Get the class declaration in which the field is actually defined

     */

    public ClassDeclaration getDefiningClassDeclaration() {

        return getClassDeclaration();

    }

    /**

     * Get the class definition

     */

    public final ClassDefinition getClassDefinition() {

        return clazz;

    }

    /**

     * Get the field's top-level enclosing class

     */

    public final ClassDefinition getTopClass() {

        return clazz.getTopClass();

    }

    /**

     * Get the field's modifiers

     */

    public final int getModifiers() {

        return modifiers;

    }

    public final void subModifiers(int mod) {

        modifiers &= ~mod;

    }

    public final void addModifiers(int mod) {

        modifiers |= mod;

    }

    /**

     * Get the field's type

     */

    public final Type getType() {

        return type;

    }

    /**

     * Get the field's name

     */

    public final Identifier getName() {

        return name;

    }

    /**

     * Get arguments (a vector of LocalMember)

     */

    public Vector<MemberDefinition> getArguments() {

        return isMethod() ? new Vector<>() : null;

    }

    /**

     * Get the exceptions that are thrown by this method.

     */

    public ClassDeclaration[] getExceptions(Environment env) {

        if (expIds != null && exp == null) {

            if (expIds.length == 0)

                exp = new ClassDeclaration[0];

            else

                // we should have translated this already!

                throw new CompilerError("getExceptions "+this);

        }

        return exp;

    }

    public final IdentifierToken[] getExceptionIds() {

        return expIds;

    }

    /**

     * Get an inner class.

     */

    public ClassDefinition getInnerClass() {

        return innerClass;

    }

    /**

     * Is this a synthetic field which holds a copy of,

     * or reference to, a local variable or enclosing instance?

     */

    public boolean isUplevelValue() {

        if (!isSynthetic() || !isVariable() || isStatic()) {

            return false;

        }

        String name = this.name.toString();

        return name.startsWith(prefixVal)

            || name.startsWith(prefixLoc)

            || name.startsWith(prefixThis);

    }

    public boolean isAccessMethod() {

        // This no longer works, because access methods

        // for constructors do not use the standard naming

        // scheme.

        //    return isSynthetic() && isMethod()

        //        && name.toString().startsWith(prefixAccess);

        // Assume that a method is an access method if it has

        // an access peer.  NOTE: An access method will not be

        // recognized as such until 'setAccessMethodTarget' has

        // been called on it.

        return isSynthetic() && isMethod() && (accessPeer != null);

    }

    /**

     * Is this a synthetic method which provides access to a

     * visible private member?

     */

    public MemberDefinition getAccessMethodTarget() {

        if (isAccessMethod()) {

            for (MemberDefinition f = accessPeer; f != null; f = f.accessPeer) {

                // perhaps skip over another access for the same field

                if (!f.isAccessMethod()) {

                    return f;

                }

            }

        }

        return null;

    }

    public void setAccessMethodTarget(MemberDefinition target) {

        if (getAccessMethodTarget() != target) {

            /*-------------------*

            if (!isAccessMethod() || accessPeer != null ||

                    target.accessPeer != null) {

                throw new CompilerError("accessPeer");

            }

            *-------------------*/

            if (accessPeer != null || target.accessPeer != null) {

                throw new CompilerError("accessPeer");

            }

            accessPeer = target;

        }

    }

    /**

     * If this method is a getter for a private field, return the setter.

     */

    public MemberDefinition getAccessUpdateMember() {

        if (isAccessMethod()) {

            for (MemberDefinition f = accessPeer; f != null; f = f.accessPeer) {

                if (f.isAccessMethod()) {

                    return f;

                }

            }

        }

        return null;

    }

    public void setAccessUpdateMember(MemberDefinition updater) {

        if (getAccessUpdateMember() != updater) {

            if (!isAccessMethod() ||

                    updater.getAccessMethodTarget() != getAccessMethodTarget()) {

                throw new CompilerError("accessPeer");

            }

            updater.accessPeer = accessPeer;

            accessPeer = updater;

        }

    }

    /**

     * Is this an access method for a field selection or method call

     * of the form '...super.foo' or '...super.foo()'?

     */

    public final boolean isSuperAccessMethod() {

        return superAccessMethod;

    }

    /**

     * Mark this member as an access method for a field selection

     * or method call via the 'super' keyword.

     */

    public final void setIsSuperAccessMethod(boolean b) {

        superAccessMethod = b;

    }

    /**

     * Tell if this is a final variable without an initializer.

     * Such variables are subject to definite single assignment.

     */

    public final boolean isBlankFinal() {

        return isFinal() && !isSynthetic() && getValue() == null;

    }

    public boolean isNeverNull() {

        if (isUplevelValue()) {

            // loc$x and this$C are never null

            return !name.toString().startsWith(prefixVal);

        }

        return false;

    }

    /**

     * Get the field's final value (may return null)

     */

    public Node getValue(Environment env) throws ClassNotFound {

        return value;

    }

    public final Node getValue() {

        return value;

    }

    public final void setValue(Node value) {

        this.value = value;

    }

    public Object getInitialValue() {

        return null;

    }

    /**

     * Get the next field or the next match

     */

    public final MemberDefinition getNextMember() {

        return nextMember;

    }

    public final MemberDefinition getNextMatch() {

        return nextMatch;

    }

    /**

     * Get the field's documentation

     */

    public String getDocumentation() {

        return documentation;

    }

    /**

     * Request a check of the field definition.

     */

    public void check(Environment env) throws ClassNotFound {

    }

    /**

     * Really check the field definition.

     */

    public Vset check(Environment env, Context ctx, Vset vset) throws ClassNotFound {

        return vset;

    }

    /**

     * Generate code

     */

    public void code(Environment env, Assembler asm) throws ClassNotFound {

        throw new CompilerError("code");

    }

    public void codeInit(Environment env, Context ctx, Assembler asm) throws ClassNotFound {

        throw new CompilerError("codeInit");

    }

    /**

     * Tells whether to report a deprecation error for this field.

     */

    public boolean reportDeprecated(Environment env) {

        return (isDeprecated() || clazz.reportDeprecated(env));

    }

    /**

     * Check if a field can reach another field (only considers

     * forward references, not the access modifiers).

     */

    public final boolean canReach(Environment env, MemberDefinition f) {

        if (f.isLocal() || !f.isVariable() || !(isVariable() || isInitializer()))

            return true;

        if ((getClassDeclaration().equals(f.getClassDeclaration())) &&

            (isStatic() == f.isStatic())) {

            // They are located in the same class, and are either both

            // static or both non-static.  Check the initialization order.

            while (((f = f.getNextMember()) != null) && (f != this));

            return f != null;

        }

        return true;

    }

    //-----------------------------------------------------------------

    // The code in this section is intended to test certain kinds of

    // compatibility between methods.  There are two kinds of compatibility

    // that the compiler may need to test.  The first is whether one

    // method can legally override another.  The second is whether two

    // method definitions can legally coexist.  We use the word `meet'

    // to mean the intersection of two legally coexisting methods.

    // For more information on these kinds of compatibility, see the

    // comments/code for checkOverride() and checkMeet() below.

    /**

     * Constants used by getAccessLevel() to represent the access

     * modifiers as numbers.

     */

    static final int PUBLIC_ACCESS = 1;

    static final int PROTECTED_ACCESS = 2;

    static final int PACKAGE_ACCESS = 3;

    static final int PRIVATE_ACCESS = 4;

    /**

     * Return the access modifier of this member as a number.  The idea

     * is that this number may be used to check properties like "the

     * access modifier of x is more restrictive than the access

     * modifier of y" with a simple inequality test:

     * "x.getAccessLevel() > y.getAccessLevel.

     *

     * This is an internal utility method.

     */

    private int getAccessLevel() {

        // Could just compute this once instead of recomputing.

        // Check to see if this is worth it.

        if (isPublic()) {

            return PUBLIC_ACCESS;

        } else if (isProtected()) {

            return PROTECTED_ACCESS;

        } else if (isPackagePrivate()) {

            return PACKAGE_ACCESS;

        } else if (isPrivate()) {

            return PRIVATE_ACCESS;

        } else {

            throw new CompilerError("getAccessLevel()");

        }

    }

    /**

     * Munge our error message to report whether the override conflict

     * came from an inherited method or a declared method.

     */

    private void reportError(Environment env, String errorString,

                             ClassDeclaration clazz,

                             MemberDefinition method) {

        if (clazz == null) {

            // For example:

            // "Instance method BLAH inherited from CLASSBLAH1 cannot be

            //  overridden by the static method declared in CLASSBLAH2."

            env.error(getWhere(), errorString,

                      this, getClassDeclaration(),

                      method.getClassDeclaration());

        } else {

            // For example:

            // "In CLASSBLAH1, instance method BLAH inherited from CLASSBLAH2

            //  cannot be overridden by the static method inherited from

            //  CLASSBLAH3."

            env.error(clazz.getClassDefinition().getWhere(),

                      //"inherit." + errorString,

                      errorString,

                      //clazz,

                      this, getClassDeclaration(),

                      method.getClassDeclaration());

        }

    }

    /**

     * Convenience method to see if two methods return the same type

     */

    public boolean sameReturnType(MemberDefinition method) {

        // Make sure both are methods.

        if (!isMethod() || !method.isMethod()) {

            throw new CompilerError("sameReturnType: not method");

        }