/*

 * Copyright (c) 1994, 2003, 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 sun.tools.java;

import java.util.Stack;

import java.io.IOException;

import sun.tools.tree.Context;

//JCOV

import java.io.File;

//end JCOV

/**

 * This class defines the environment for a compilation.

 * It is used to load classes, resolve class names and

 * report errors. It is an abstract class, a subclass

 * must define implementations for some of the functions.<p>

 *

 * An environment has a source object associated with it.

 * This is the thing against which errors are reported, it

 * is usually a file name, a field or a class.<p>

 *

 * Environments can be nested to change the source object.<p>

 *

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

 *

 * @author      Arthur van Hoff

 */

public class Environment implements Constants {

    /**

     * The actual environment to which everything is forwarded.

     */

    Environment env;

    /**

     * External character encoding name

     */

    String encoding;

    /**

     * The object that is currently being parsed/compiled.

     * It is either a file name (String) or a field (MemberDefinition)

     * or a class (ClassDeclaration or ClassDefinition).

     */

    Object source;

    public Environment(Environment env, Object source) {

        if (env != null && env.env != null && env.getClass() == this.getClass())

            env = env.env;      // a small optimization

        this.env = env;

        this.source = source;

    }

    public Environment() {

        this(null, null);

    }

    /**

     * Tells whether an Identifier refers to a package which should be

     * exempt from the "exists" check in Imports#resolve().

     */

    public boolean isExemptPackage(Identifier id) {

        return env.isExemptPackage(id);

    }

    /**

     * Return a class declaration given a fully qualified class name.

     */

    public ClassDeclaration getClassDeclaration(Identifier nm) {

        return env.getClassDeclaration(nm);

    }

    /**

     * Return a class definition given a fully qualified class name.

     * <p>

     * Should be called only with 'internal' class names, i.e., the result

     * of a call to 'resolveName' or a synthetic class name.

     */

    public final ClassDefinition getClassDefinition(Identifier nm) throws ClassNotFound {

        if (nm.isInner()) {

            ClassDefinition c = getClassDefinition(nm.getTopName());

            Identifier tail = nm.getFlatName();

        walkTail:

            while (tail.isQualified()) {

                tail = tail.getTail();

                Identifier head = tail.getHead();

                //System.out.println("CLASS: " + c + " HEAD: " + head + " TAIL: " + tail);

                String hname = head.toString();

                // If the name is of the form 'ClassName.N$localName', where N is

                // a number, the field 'N$localName' may not necessarily be a member

                // of the class named by 'ClassName', but might be a member of some

                // inaccessible class contained within it.  We use 'getLocalClass'

                // to do the lookup in this case.  This is part of a fix for bugid

                // 4054523 and 4030421.  See also 'BatchEnvironment.makeClassDefinition'.

                // This should also work for anonymous class names of the form

                // 'ClassName.N'.  Note that the '.' qualifications get converted to

                // '$' characters when determining the external name of the class and

                // the name of the class file.

                if (hname.length() > 0

                    && Character.isDigit(hname.charAt(0))) {

                    ClassDefinition localClass = c.getLocalClass(hname);

                    if (localClass != null) {

                        c = localClass;

                        continue walkTail;

                    }

                } else {

                    for (MemberDefinition f = c.getFirstMatch(head);

                         f != null; f = f.getNextMatch()) {

                        if (f.isInnerClass()) {

                            c = f.getInnerClass();

                            continue walkTail;

                        }

                    }

                }

                throw new ClassNotFound(Identifier.lookupInner(c.getName(), head));

            }

            //System.out.println("FOUND " + c + " FOR " + nm);

            return c;

        }

        return getClassDeclaration(nm).getClassDefinition(this);

    }

    /**

     * Return a class declaration given a type. Only works for

     * class types.

     */

    public ClassDeclaration getClassDeclaration(Type t) {

        return getClassDeclaration(t.getClassName());

    }

    /**

     * Return a class definition given a type. Only works for

     * class types.

     */

    public final ClassDefinition getClassDefinition(Type t) throws ClassNotFound {

        return getClassDefinition(t.getClassName());

    }

    /**

     * Check if a class exists (without actually loading it).

     * (Since inner classes cannot in general be examined without

     * loading source, this method does not accept inner names.)

     */

    public boolean classExists(Identifier nm) {

        return env.classExists(nm);

    }

    public final boolean classExists(Type t) {

        return !t.isType(TC_CLASS) || classExists(t.getClassName());

    }

    /**

     * Get the package path for a package

     */

    public Package getPackage(Identifier pkg) throws IOException {

        return env.getPackage(pkg);

    }

    /**

     * Load the definition of a class.

     */

    public void loadDefinition(ClassDeclaration c) {

        env.loadDefinition(c);

    }

    /**

     * Return the source of the environment (ie: the thing being compiled/parsed).

     */

    public final Object getSource() {

        return source;

    }

    /**

     * Resolve a type. Make sure that all the classes referred to by

     * the type have a definition.  Report errors.  Return true if

     * the type is well-formed.  Presently used for types appearing

     * in member declarations, which represent named types internally as

     * qualified identifiers.  Type names appearing in local variable

     * declarations and within expressions are represented as identifier

     * or field expressions, and are resolved by 'toType', which delegates

     * handling of the non-inner portion of the name to this method.

     * <p>

     * In 'toType', the various stages of qualification are represented by

     * separate AST nodes.  Here, we are given a single identifier which

     * contains the entire qualification structure.  It is not possible in

     * general to set the error location to the exact position of a component

     * that is in error, so an error message must refer to the entire qualified

     * name.  An attempt to keep track of the string length of the components of

     * the name and to offset the location accordingly fails because the initial

     * prefix of the name may have been rewritten by an earlier call to

     * 'resolveName'.  See 'SourceMember.resolveTypeStructure'.  The situation

     * is actually even worse than this, because only a single location is

     * passed in for an entire declaration, which may contain many type names.

     * All error messages are thus poorly localized.  These checks should be

     * done while traversing the parse tree for the type, not the type descriptor.

     * <p>

     * DESIGN NOTE:

     * As far as I can tell, the two-stage resolution of names represented in

     * string form is an artifact of the late implementation of inner classes

     * and the use of mangled names internally within the compiler.  All

     * qualified names should have their hiearchical structure made explicit

     * in the parse tree at the phase at which they are presented for static

     * semantic checking.  This would affect class names appearing in 'extends',

     * 'implements', and 'throws' clauses, as well as in member declarations.

     */

    public boolean resolve(long where, ClassDefinition c, Type t) {

        switch (t.getTypeCode()) {

          case TC_CLASS: {

            ClassDefinition def;

            try {

                Identifier nm = t.getClassName();

                if (!nm.isQualified() && !nm.isInner() && !classExists(nm)) {

                    resolve(nm);        // elicit complaints about ambiguity

                }

                def = getQualifiedClassDefinition(where, nm, c, false);

                if (!c.canAccess(this, def.getClassDeclaration())) {

                    // Reported error location may be imprecise

                    // if the name is qualified.

                    error(where, "cant.access.class", def);

                    return true; // return false later

                }

                def.noteUsedBy(c, where, env);

            } catch (AmbiguousClass ee) {

                error(where, "ambig.class", ee.name1, ee.name2);

                return false;

            } catch (ClassNotFound e) {

                // For now, report "class.and.package" only when the code

                // is going to fail anyway.

                try {

                    if (e.name.isInner() &&

                            getPackage(e.name.getTopName()).exists()) {

                        env.error(where, "class.and.package",

                                  e.name.getTopName());

                    }

                } catch (IOException ee) {

                    env.error(where, "io.exception", "package check");

                }

                // This error message is also emitted for 'new' expressions.

                // error(where, "class.not.found", e.name, "declaration");

                error(where, "class.not.found.no.context", e.name);

                return false;

            }

            return true;

          }

          case TC_ARRAY:

            return resolve(where, c, t.getElementType());

          case TC_METHOD:

            boolean ok = resolve(where, c, t.getReturnType());

            Type args[] = t.getArgumentTypes();

            for (int i = args.length ; i-- > 0 ; ) {

                ok &= resolve(where, c, args[i]);

            }

            return ok;

        }

        return true;

    }

    /**

     * Given its fully-qualified name, verify that a class is defined and accessible.

     * Used to check components of qualified names in contexts where a class is expected.

     * Like 'resolve', but is given a single type name, not a type descriptor.

     */

    public boolean resolveByName(long where, ClassDefinition c, Identifier nm) {

        return resolveByName(where, c, nm, false);

    }

    public boolean resolveExtendsByName(long where, ClassDefinition c, Identifier nm) {

        return resolveByName(where, c, nm, true);

    }

    private boolean resolveByName(long where, ClassDefinition c,

                                 Identifier nm, boolean isExtends) {

        ClassDefinition def;

        try {

            if (!nm.isQualified() && !nm.isInner() && !classExists(nm)) {

                resolve(nm);    // elicit complaints about ambiguity

            }

            def = getQualifiedClassDefinition(where, nm, c, isExtends);

            ClassDeclaration decl = def.getClassDeclaration();

            if (!((!isExtends && c.canAccess(this, decl))

                  ||

                  (isExtends && c.extendsCanAccess(this, decl)))) {

                error(where, "cant.access.class", def);

                return true; // return false later

            }

        } catch (AmbiguousClass ee) {

            error(where, "ambig.class", ee.name1, ee.name2);

            return false;

        } catch (ClassNotFound e) {

            // For now, report "class.and.package" only when the code

            // is going to fail anyway.

            try {

                if (e.name.isInner() &&

                    getPackage(e.name.getTopName()).exists()) {

                    env.error(where, "class.and.package",

                              e.name.getTopName());

                }

            } catch (IOException ee) {

                env.error(where, "io.exception", "package check");

            }

            error(where, "class.not.found", e.name, "type name");

            return false;

        }

        return true;

    }

    /**

     * Like 'getClassDefinition(env)', but check access on each component.

     * Currently called only by 'resolve' above.  It is doubtful that calls

     * to 'getClassDefinition(env)' are appropriate now.

     */

    public final ClassDefinition

    getQualifiedClassDefinition(long where,

                                Identifier nm,

                                ClassDefinition ctxClass,

                                boolean isExtends) throws ClassNotFound {

        if (nm.isInner()) {

            ClassDefinition c = getClassDefinition(nm.getTopName());

            Identifier tail = nm.getFlatName();

        walkTail:

            while (tail.isQualified()) {

                tail = tail.getTail();

                Identifier head = tail.getHead();

                // System.out.println("CLASS: " + c + " HEAD: " + head + " TAIL: " + tail);

                String hname = head.toString();

                // Handle synthesized names of local and anonymous classes.

                // See 'getClassDefinition(env)' above.

                if (hname.length() > 0

                    && Character.isDigit(hname.charAt(0))) {

                    ClassDefinition localClass = c.getLocalClass(hname);

                    if (localClass != null) {

                        c = localClass;

                        continue walkTail;

                    }

                } else {

                    for (MemberDefinition f = c.getFirstMatch(head);

                         f != null; f = f.getNextMatch()) {

                        if (f.isInnerClass()) {

                            ClassDeclaration rdecl = c.getClassDeclaration();

                            c = f.getInnerClass();

                            ClassDeclaration fdecl = c.getClassDeclaration();

                            // This check is presumably applicable even if the

                            // original source-code name (expanded by 'resolveNames')

                            // was a simple, unqualified name.  Hopefully, JLS 2e

                            // will clarify the matter.

                            if ((!isExtends

                                 && !ctxClass.canAccess(env, fdecl))

                                ||

                                (isExtends

                                 && !ctxClass.extendsCanAccess(env, fdecl))) {

                                // Reported error location is imprecise.

                                env.error(where, "no.type.access", head, rdecl, ctxClass);

                            }

                            // The JLS 6.6.2 restrictions on access to protected members

                            // depend in an essential way upon the syntactic form of the name.

                            // Since the compiler has previously expanded the class names

                            // here into fully-qualified form ('resolveNames'), this check

                            // cannot be performed here.  Unfortunately, the original names

                            // are clobbered during 'basicCheck', which is also the phase that

                            // resolves the inheritance structure, required to implement the

                            // access restrictions.  Pending a large-scale revision of the

                            // name-resolution machinery, we forgo this check, with the result

                            // that the JLS 6.6.2 restrictions are not enforced for some cases

                            // of qualified access to inner classes.  Some qualified names are

                            // resolved elsewhere via a different mechanism, and will be

                            // treated correctly -- see 'FieldExpression.checkCommon'.

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

                            if (f.isProtected()) {

                                Type rty = Type.tClass(rdecl.getName()); // hack

                                if (!ctxClass.protectedAccess(env, f, rty)) {

                                    // Reported error location is imprecise.

                                    env.error(where, "invalid.protected.type.use",

                                              head, ctxClass, rty);

                                }

                            }

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

                            continue walkTail;

                        }

                    }

                }

                throw new ClassNotFound(Identifier.lookupInner(c.getName(), head));

            }

            //System.out.println("FOUND " + c + " FOR " + nm);

            return c;

        }

        return getClassDeclaration(nm).getClassDefinition(this);

    }

    /**

     * Resolve the names within a type, returning the adjusted type.

     * Adjust class names to reflect scoping.

     * Do not report errors.

     * <p>

     * NOTE: It would be convenient to check for errors here, such as

     * verifying that each component of a qualified name exists and is

     * accessible.  Why must this be done in a separate phase?

     * <p>

     * If the 'synth' argument is true, indicating that the member whose

     * type is being resolved is synthetic, names are resolved with respect

     * to the package scope.  (Fix for 4097882)

     */

    public Type resolveNames(ClassDefinition c, Type t, boolean synth) {

        if (tracing) dtEvent("Environment.resolveNames: " + c + ", " + t);

        switch (t.getTypeCode()) {

          case TC_CLASS: {

            Identifier name = t.getClassName();

            Identifier rname;

            if (synth) {

                rname = resolvePackageQualifiedName(name);

            } else {

                rname = c.resolveName(this, name);

            }

            if (name != rname) {

                t = Type.tClass(rname);

            }

            break;

          }

          case TC_ARRAY:

            t = Type.tArray(resolveNames(c, t.getElementType(), synth));

            break;

          case TC_METHOD: {

            Type ret = t.getReturnType();

            Type rret = resolveNames(c, ret, synth);

            Type args[] = t.getArgumentTypes();

            Type rargs[] = new Type[args.length];

            boolean changed = (ret != rret);

            for (int i = args.length ; i-- > 0 ; ) {

                Type arg = args[i];

                Type rarg = resolveNames(c, arg, synth);

                rargs[i] = rarg;

                if (arg != rarg) {

                    changed = true;

                }

            }

            if (changed) {

                t = Type.tMethod(rret, rargs);

            }

            break;

          }

        }

        return t;

    }

    /**

     * Resolve a class name, using only package and import directives.

     * Report no errors.

     * <p>

     */

    public Identifier resolveName(Identifier name) {

        // This logic is pretty exactly parallel to that of

        // ClassDefinition.resolveName().

        if (name.isQualified()) {

            // Try to resolve the first identifier component,

            // because inner class names take precedence over

            // package prefixes.  (Cf. ClassDefinition.resolveName.)

            Identifier rhead = resolveName(name.getHead());

            if (rhead.hasAmbigPrefix()) {

                // The first identifier component refers to an

                // ambiguous class.  Limp on.  We throw away the

                // rest of the classname as it is irrelevant.

                // (part of solution for 4059855).

                return rhead;

            }

            if (!this.classExists(rhead)) {

                return this.resolvePackageQualifiedName(name);

            }

            try {

                return this.getClassDefinition(rhead).

                    resolveInnerClass(this, name.getTail());

            } catch (ClassNotFound ee) {

                // return partially-resolved name someone else can fail on

                return Identifier.lookupInner(rhead, name.getTail());

            }

        }

        try {

            return resolve(name);

        } catch (AmbiguousClass ee) {

            // Don't force a resolution of the name if it is ambiguous.

            // Forcing the resolution would tack the current package

            // name onto the front of the class, which would be wrong.

            // Instead, mark the name as ambiguous and let a later stage

            // find the error by calling env.resolve(name).

            // (part of solution for 4059855).

            if (name.hasAmbigPrefix()) {

                return name;

            } else {

                return name.addAmbigPrefix();

            }

        } catch (ClassNotFound ee) {

            // last chance to make something halfway sensible

            Imports imports = getImports();

            if (imports != null)

                return imports.forceResolve(this, name);

        }

        return name;

    }