/*

 * Copyright (c) 2003, 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.comp;

import java.util.HashSet;

import java.util.Set;

import javax.tools.JavaFileObject;

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

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.Scope.ImportFilter;

import com.sun.tools.javac.code.Scope.NamedImportScope;

import com.sun.tools.javac.code.Scope.StarImportScope;

import com.sun.tools.javac.code.Scope.WriteableScope;

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

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.DefinedBy.Api;

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

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

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

import static com.sun.tools.javac.code.Flags.*;

import static com.sun.tools.javac.code.Flags.ANNOTATION;

import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import static com.sun.tools.javac.code.TypeTag.CLASS;

import static com.sun.tools.javac.code.TypeTag.ERROR;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

import com.sun.tools.javac.util.Dependencies.AttributionKind;

import com.sun.tools.javac.util.Dependencies.CompletionCause;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

/** This is the second phase of Enter, in which classes are completed

 *  by resolving their headers and entering their members in the into

 *  the class scope. See Enter for an overall overview.

 *

 *  This class uses internal phases to process the classes. When a phase

 *  processes classes, the lower phases are not invoked until all classes

 *  pass through the current phase. Note that it is possible that upper phases

 *  are run due to recursive completion. The internal phases are:

 *  - ImportPhase: shallow pass through imports, adds information about imports

 *                 the NamedImportScope and StarImportScope, but avoids queries

 *                 about class hierarchy.

 *  - HierarchyPhase: resolves the supertypes of the given class. Does not handle

 *                    type parameters of the class or type argument of the supertypes.

 *  - HeaderPhase: finishes analysis of the header of the given class by resolving

 *                 type parameters, attributing supertypes including type arguments

 *                 and scheduling full annotation attribution. This phase also adds

 *                 a synthetic default constructor if needed and synthetic "this" field.

 *  - MembersPhase: resolves headers for fields, methods and constructors in the given class.

 *                  Also generates synthetic enum members.

 *

 *  <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 class TypeEnter implements Completer {

    protected static final Context.Key<TypeEnter> typeEnterKey = new Context.Key<>();

    /** A switch to determine whether we check for package/class conflicts

     */

    final static boolean checkClash = true;

    private final Names names;

    private final Enter enter;

    private final MemberEnter memberEnter;

    private final Log log;

    private final Check chk;

    private final Attr attr;

    private final Symtab syms;

    private final TreeMaker make;

    private final Todo todo;

    private final Annotate annotate;

    private final TypeAnnotations typeAnnotations;

    private final Types types;

    private final JCDiagnostic.Factory diags;

    private final Source source;

    private final DeferredLintHandler deferredLintHandler;

    private final Lint lint;

    private final TypeEnvs typeEnvs;

    private final Dependencies dependencies;

    public static TypeEnter instance(Context context) {

        TypeEnter instance = context.get(typeEnterKey);

        if (instance == null)

            instance = new TypeEnter(context);

        return instance;

    }

    protected TypeEnter(Context context) {

        context.put(typeEnterKey, this);

        names = Names.instance(context);

        enter = Enter.instance(context);

        memberEnter = MemberEnter.instance(context);

        log = Log.instance(context);

        chk = Check.instance(context);

        attr = Attr.instance(context);

        syms = Symtab.instance(context);

        make = TreeMaker.instance(context);

        todo = Todo.instance(context);

        annotate = Annotate.instance(context);

        typeAnnotations = TypeAnnotations.instance(context);

        types = Types.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        source = Source.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        lint = Lint.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        dependencies = Dependencies.instance(context);

        allowTypeAnnos = source.allowTypeAnnotations();

        allowDeprecationOnImport = source.allowDeprecationOnImport();

    }

    /** Switch: support type annotations.

     */

    boolean allowTypeAnnos;

    /**

     * Switch: should deprecation warnings be issued on import

     */

    boolean allowDeprecationOnImport;

    /** A flag to disable completion from time to time during member

     *  enter, as we only need to look up types.  This avoids

     *  unnecessarily deep recursion.

     */

    boolean completionEnabled = true;

    /* Verify Imports:

     */

    protected void ensureImportsChecked(List<JCCompilationUnit> trees) {

        // if there remain any unimported toplevels (these must have

        // no classes at all), process their import statements as well.

        for (JCCompilationUnit tree : trees) {

                Env<AttrContext> topEnv = enter.topLevelEnv(tree);

                finishImports(tree, () -> { completeClass.resolveImports(tree, topEnv); });

            }

       }

    }

/* ********************************************************************

 * Source completer

 *********************************************************************/

    /** Complete entering a class.

     *  @param sym         The symbol of the class to be completed.

     */

    public void complete(Symbol sym) throws CompletionFailure {

        // Suppress some (recursive) MemberEnter invocations

        if (!completionEnabled) {

            // Re-install same completer for next time around and return.

            Assert.check((sym.flags() & Flags.COMPOUND) == 0);

            sym.completer = this;

            return;

        }

        try {

            annotate.enterStart();

            sym.flags_field |= UNATTRIBUTED;

            List<Env<AttrContext>> queue;

            dependencies.push((ClassSymbol) sym, CompletionCause.MEMBER_ENTER);

            try {

                queue = completeClass.runPhase(List.of(typeEnvs.get((ClassSymbol) sym)));

            } finally {

                dependencies.pop();

            }

            if (!queue.isEmpty()) {

                Set<JCCompilationUnit> seen = new HashSet<>();

                for (Env<AttrContext> env : queue) {

                    if (env.toplevel.defs.contains(env.enclClass) && seen.add(env.toplevel)) {

                        finishImports(env.toplevel, () -> {});

                    }

                }

            }

        } finally {

            annotate.enterDone();

        }

    }

    void finishImports(JCCompilationUnit toplevel, Runnable resolve) {

        JavaFileObject prev = log.useSource(toplevel.sourcefile);

        try {

            resolve.run();

            chk.checkImportsUnique(toplevel);

            chk.checkImportsResolvable(toplevel);

            toplevel.namedImportScope.finalizeScope();

            toplevel.starImportScope.finalizeScope();

        } finally {

            log.useSource(prev);

        }

    }

    abstract class Phase {

        private final ListBuffer<Env<AttrContext>> queue = new ListBuffer<>();

        private final Phase next;

        private final CompletionCause phaseName;

        Phase(CompletionCause phaseName, Phase next) {

            this.phaseName = phaseName;

            this.next = next;

        }

        public List<Env<AttrContext>> runPhase(List<Env<AttrContext>> envs) {

            boolean firstToComplete = queue.isEmpty();

            for (Env<AttrContext> env : envs) {

                JCClassDecl tree = (JCClassDecl)env.tree;

                queue.add(env);

                JavaFileObject prev = log.useSource(env.toplevel.sourcefile);

                DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());

                try {

                    dependencies.push(env.enclClass.sym, phaseName);

                    doRunPhase(env);

                } catch (CompletionFailure ex) {

                    chk.completionError(tree.pos(), ex);

                } finally {

                    dependencies.pop();

                    deferredLintHandler.setPos(prevLintPos);

                    log.useSource(prev);

                }

            }

            if (firstToComplete) {

                List<Env<AttrContext>> out = queue.toList();

                queue.clear();

                return next != null ? next.runPhase(out) : out;

            } else {

                return List.nil();

            }

       }

        protected abstract void doRunPhase(Env<AttrContext> env);

    }

    private final ImportsPhase completeClass = new ImportsPhase();

    /**Analyze import clauses.

     */

    private final class ImportsPhase extends Phase {

        public ImportsPhase() {

            super(CompletionCause.IMPORTS_PHASE, new HierarchyPhase());

        }

        Env<AttrContext> env;

        ImportFilter staticImportFilter;

        @Override

        protected void doRunPhase(Env<AttrContext> env) {

            JCClassDecl tree = env.enclClass;

            ClassSymbol sym = tree.sym;

            // If sym is a toplevel-class, make sure any import

            // clauses in its source file have been seen.

            if (sym.owner.kind == PCK) {

                resolveImports(env.toplevel, env.enclosing(TOPLEVEL));

                todo.append(env);

            }

            if (sym.owner.kind == TYP)

                sym.owner.complete();

        }

        private void resolveImports(JCCompilationUnit tree, Env<AttrContext> env) {

                // we must have already processed this toplevel

                return;

            }

            ImportFilter prevStaticImportFilter = staticImportFilter;

            DiagnosticPosition prevLintPos = deferredLintHandler.immediate();

            Lint prevLint = chk.setLint(lint);

            Env<AttrContext> prevEnv = this.env;

            try {

                this.env = env;

                final PackageSymbol packge = env.toplevel.packge;

                // Import-on-demand java.lang.

                importAll(tree.pos, syms.enterPackage(names.java_lang), env);

                // Process the package def and all import clauses.

                if (tree.getPackage() != null)

                    checkClassPackageClash(tree.getPackage());

                for (JCImport imp : tree.getImports()) {

                    doImport(imp);

                }

            } finally {

                this.env = prevEnv;

                chk.setLint(prevLint);

                deferredLintHandler.setPos(prevLintPos);

                this.staticImportFilter = prevStaticImportFilter;

            }

        }

        private void checkClassPackageClash(JCPackageDecl tree) {

            // check that no class exists with same fully qualified name as

            // toplevel package

            if (checkClash && tree.pid != null) {

                Symbol p = env.toplevel.packge;

                while (p.owner != syms.rootPackage) {

                    p.owner.complete(); // enter all class members of p

                    if (syms.classes.get(p.getQualifiedName()) != null) {

                        log.error(tree.pos,

                                  "pkg.clashes.with.class.of.same.name",

                                  p);

                    }

                    p = p.owner;

                }

            }

            // process package annotations

            annotate.annotateLater(tree.annotations, env, env.toplevel.packge, null);

        }

        private void doImport(JCImport tree) {

            dependencies.push(AttributionKind.IMPORT, tree);

            JCFieldAccess imp = (JCFieldAccess)tree.qualid;

            Name name = TreeInfo.name(imp);

            // Create a local environment pointing to this tree to disable

            // effects of other imports in Resolve.findGlobalType

            Env<AttrContext> localEnv = env.dup(tree);

            TypeSymbol p = attr.attribImportQualifier(tree, localEnv).tsym;

            if (name == names.asterisk) {

                // Import on demand.

                chk.checkCanonical(imp.selected);

                if (tree.staticImport)

                    importStaticAll(tree.pos, p, env);

                else

                    importAll(tree.pos, p, env);

            } else {

                // Named type import.

                if (tree.staticImport) {

                    importNamedStatic(tree.pos(), p, name, localEnv, tree);

                    chk.checkCanonical(imp.selected);

                } else {

                    TypeSymbol c = attribImportType(imp, localEnv).tsym;

                    chk.checkCanonical(imp);

                    importNamed(tree.pos(), c, env, tree);

                }

            }

            dependencies.pop();

        }

        Type attribImportType(JCTree tree, Env<AttrContext> env) {

            Assert.check(completionEnabled);

            Lint prevLint = chk.setLint(allowDeprecationOnImport ?

                    lint : lint.suppress(LintCategory.DEPRECATION));

            try {

                // To prevent deep recursion, suppress completion of some

                // types.

                completionEnabled = false;

                return attr.attribType(tree, env);

            } finally {

                completionEnabled = true;

                chk.setLint(prevLint);

            }

        }

        /** Import all classes of a class or package on demand.

         *  @param pos           Position to be used for error reporting.

         *  @param tsym          The class or package the members of which are imported.

         *  @param env           The env in which the imported classes will be entered.

         */

        private void importAll(int pos,

                               final TypeSymbol tsym,

                               Env<AttrContext> env) {

            // Check that packages imported from exist (JLS ???).

            if (tsym.kind == PCK && tsym.members().isEmpty() && !tsym.exists()) {

                // If we can't find java.lang, exit immediately.

                if (((PackageSymbol)tsym).fullname.equals(names.java_lang)) {

                    JCDiagnostic msg = diags.fragment("fatal.err.no.java.lang");

                    throw new FatalError(msg);

                } else {

                    log.error(DiagnosticFlag.RESOLVE_ERROR, pos, "doesnt.exist", tsym);

                }

            }

            env.toplevel.starImportScope.importAll(types, tsym.members(), typeImportFilter, false);

        }

        /** Import all static members of a class or package on demand.

         *  @param pos           Position to be used for error reporting.

         *  @param tsym          The class or package the members of which are imported.

         *  @param env           The env in which the imported classes will be entered.

         */

        private void importStaticAll(int pos,

                                     final TypeSymbol tsym,

                                     Env<AttrContext> env) {

            final StarImportScope toScope = env.toplevel.starImportScope;

            final TypeSymbol origin = tsym;

            toScope.importAll(types, origin.members(), staticImportFilter, true);

        }

        /** Import statics types of a given name.  Non-types are handled in Attr.

         *  @param pos           Position to be used for error reporting.

         *  @param tsym          The class from which the name is imported.

         *  @param name          The (simple) name being imported.

         *  @param env           The environment containing the named import

         *                  scope to add to.

         */

        private void importNamedStatic(final DiagnosticPosition pos,

                                       final TypeSymbol tsym,

                                       final Name name,

                                       final Env<AttrContext> env,

                                       final JCImport imp) {

            if (tsym.kind != TYP) {

                log.error(DiagnosticFlag.RECOVERABLE, pos, "static.imp.only.classes.and.interfaces");

                return;

            }

            final NamedImportScope toScope = env.toplevel.namedImportScope;

            final Scope originMembers = tsym.members();

            imp.importScope = toScope.importByName(types, originMembers, name, staticImportFilter);

        }

        /** Import given class.

         *  @param pos           Position to be used for error reporting.

         *  @param tsym          The class to be imported.

         *  @param env           The environment containing the named import

         *                  scope to add to.

         */

        private void importNamed(DiagnosticPosition pos, final Symbol tsym, Env<AttrContext> env, JCImport imp) {

            if (tsym.kind == TYP)

                imp.importScope = env.toplevel.namedImportScope.importType(tsym.owner.members(), tsym.owner.members(), tsym);

        }

    }

    /**Defines common utility methods used by the HierarchyPhase and HeaderPhase.

     */

    private abstract class AbstractHeaderPhase extends Phase {

        public AbstractHeaderPhase(CompletionCause phaseName, Phase next) {

            super(phaseName, next);

        }

        protected Env<AttrContext> baseEnv(JCClassDecl tree, Env<AttrContext> env) {

            WriteableScope baseScope = WriteableScope.create(tree.sym);

            //import already entered local classes into base scope

            for (Symbol sym : env.outer.info.scope.getSymbols(NON_RECURSIVE)) {

                if (sym.isLocal()) {

                    baseScope.enter(sym);

                }

            }

            //import current type-parameters into base scope

            if (tree.typarams != null)