/*

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

import java.util.Map.Entry;

import java.util.function.Function;

import java.util.stream.Stream;

import com.sun.source.tree.CaseTree.CaseKind;

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

import com.sun.tools.javac.code.Kinds.KindSelector;

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

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

import com.sun.tools.javac.main.Option.PkgInfo;

import com.sun.tools.javac.resources.CompilerProperties.Fragments;

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

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

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

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

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

import com.sun.tools.javac.code.Symbol.OperatorSymbol.AccessCode;

import com.sun.tools.javac.resources.CompilerProperties.Errors;

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

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

import com.sun.tools.javac.jvm.Target;

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

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

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

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

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

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

import static com.sun.tools.javac.code.Symbol.OperatorSymbol.AccessCode.DEREF;

import static com.sun.tools.javac.jvm.ByteCodes.*;

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

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

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

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

import static com.sun.tools.javac.tree.JCTree.JCOperatorExpression.OperandPos.LEFT;

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

/** This pass translates away some syntactic sugar: inner classes,

 *  class literals, assertions, foreach loops, etc.

 *

 *  <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 Lower extends TreeTranslator {

    protected static final Context.Key<Lower> lowerKey = new Context.Key<>();

    public static Lower instance(Context context) {

        Lower instance = context.get(lowerKey);

        if (instance == null)

            instance = new Lower(context);

        return instance;

    }

    private final Names names;

    private final Log log;

    private final Symtab syms;

    private final Resolve rs;

    private final Operators operators;

    private final Check chk;

    private final Attr attr;

    private TreeMaker make;

    private DiagnosticPosition make_pos;

    private final ClassWriter writer;

    private final ConstFold cfolder;

    private final Target target;

    private final Source source;

    private final TypeEnvs typeEnvs;

    private final Name dollarAssertionsDisabled;

    private final Name classDollar;

    private final Name dollarCloseResource;

    private final Types types;

    private final boolean debugLower;

    private final boolean disableProtectedAccessors; // experimental

    private final PkgInfo pkginfoOpt;

    protected Lower(Context context) {

        context.put(lowerKey, this);

        names = Names.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        rs = Resolve.instance(context);

        operators = Operators.instance(context);

        chk = Check.instance(context);

        attr = Attr.instance(context);

        make = TreeMaker.instance(context);

        writer = ClassWriter.instance(context);

        cfolder = ConstFold.instance(context);

        target = Target.instance(context);

        source = Source.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        dollarAssertionsDisabled = names.

            fromString(target.syntheticNameChar() + "assertionsDisabled");

        classDollar = names.

            fromString("class" + target.syntheticNameChar());

        dollarCloseResource = names.

            fromString(target.syntheticNameChar() + "closeResource");

        types = Types.instance(context);

        Options options = Options.instance(context);

        debugLower = options.isSet("debuglower");

        pkginfoOpt = PkgInfo.get(options);

        disableProtectedAccessors = options.isSet("disableProtectedAccessors");

    }

    /** The currently enclosing class.

     */

    ClassSymbol currentClass;

    /** A queue of all translated classes.

     */

    ListBuffer<JCTree> translated;

    /** Environment for symbol lookup, set by translateTopLevelClass.

     */

    Env<AttrContext> attrEnv;

    /** A hash table mapping syntax trees to their ending source positions.

     */

    EndPosTable endPosTable;

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

 * Global mappings

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

    /** A hash table mapping local classes to their definitions.

     */

    Map<ClassSymbol, JCClassDecl> classdefs;

    /** A hash table mapping local classes to a list of pruned trees.

     */

    public Map<ClassSymbol, List<JCTree>> prunedTree = new WeakHashMap<>();

    /** A hash table mapping virtual accessed symbols in outer subclasses

     *  to the actually referred symbol in superclasses.

     */

    Map<Symbol,Symbol> actualSymbols;

    /** The current method definition.

     */

    JCMethodDecl currentMethodDef;

    /** The current method symbol.

     */

    MethodSymbol currentMethodSym;

    /** The currently enclosing outermost class definition.

     */

    JCClassDecl outermostClassDef;

    /** The currently enclosing outermost member definition.

     */

    JCTree outermostMemberDef;

    /** A map from local variable symbols to their translation (as per LambdaToMethod).

     * This is required when a capturing local class is created from a lambda (in which

     * case the captured symbols should be replaced with the translated lambda symbols).

     */

    Map<Symbol, Symbol> lambdaTranslationMap = null;

    /** A navigator class for assembling a mapping from local class symbols

     *  to class definition trees.

     *  There is only one case; all other cases simply traverse down the tree.

     */

    class ClassMap extends TreeScanner {

        /** All encountered class defs are entered into classdefs table.

         */

        public void visitClassDef(JCClassDecl tree) {

            classdefs.put(tree.sym, tree);

            super.visitClassDef(tree);

        }

    }

    ClassMap classMap = new ClassMap();

    /** Map a class symbol to its definition.

     *  @param c    The class symbol of which we want to determine the definition.

     */

    JCClassDecl classDef(ClassSymbol c) {

        // First lookup the class in the classdefs table.

        JCClassDecl def = classdefs.get(c);

        if (def == null && outermostMemberDef != null) {

            // If this fails, traverse outermost member definition, entering all

            // local classes into classdefs, and try again.

            classMap.scan(outermostMemberDef);

            def = classdefs.get(c);

        }

        if (def == null) {

            // If this fails, traverse outermost class definition, entering all

            // local classes into classdefs, and try again.

            classMap.scan(outermostClassDef);

            def = classdefs.get(c);

        }

        return def;

    }

    /** A hash table mapping class symbols to lists of free variables.

     *  accessed by them. Only free variables of the method immediately containing

     *  a class are associated with that class.

     */

    Map<ClassSymbol,List<VarSymbol>> freevarCache;

    /** A navigator class for collecting the free variables accessed

     *  from a local class. There is only one case; all other cases simply

     *  traverse down the tree. This class doesn't deal with the specific

     *  of Lower - it's an abstract visitor that is meant to be reused in

     *  order to share the local variable capture logic.

     */

    abstract class BasicFreeVarCollector extends TreeScanner {

        /** Add all free variables of class c to fvs list

         *  unless they are already there.

         */

        abstract void addFreeVars(ClassSymbol c);

        /** If tree refers to a variable in owner of local class, add it to

         *  free variables list.

         */

        public void visitIdent(JCIdent tree) {

            visitSymbol(tree.sym);

        }

        // where

        abstract void visitSymbol(Symbol _sym);

        /** If tree refers to a class instance creation expression

         *  add all free variables of the freshly created class.

         */

        public void visitNewClass(JCNewClass tree) {

            ClassSymbol c = (ClassSymbol)tree.constructor.owner;

            addFreeVars(c);

            super.visitNewClass(tree);

        }

        /** If tree refers to a superclass constructor call,

         *  add all free variables of the superclass.

         */

        public void visitApply(JCMethodInvocation tree) {

            if (TreeInfo.name(tree.meth) == names._super) {

                addFreeVars((ClassSymbol) TreeInfo.symbol(tree.meth).owner);

            }

            super.visitApply(tree);

        }

        @Override

        public void visitBreak(JCBreak tree) {

            if (tree.isValueBreak())

                scan(tree.value);

        }

    }

    /**

     * Lower-specific subclass of {@code BasicFreeVarCollector}.

     */

    class FreeVarCollector extends BasicFreeVarCollector {

        /** The owner of the local class.

         */

        Symbol owner;

        /** The local class.

         */

        ClassSymbol clazz;

        /** The list of owner's variables accessed from within the local class,

         *  without any duplicates.

         */

        List<VarSymbol> fvs;

        FreeVarCollector(ClassSymbol clazz) {

            this.clazz = clazz;

            this.owner = clazz.owner;

            this.fvs = List.nil();

        }

        /** Add free variable to fvs list unless it is already there.

         */

        private void addFreeVar(VarSymbol v) {

            for (List<VarSymbol> l = fvs; l.nonEmpty(); l = l.tail)

                if (l.head == v) return;

            fvs = fvs.prepend(v);

        }

        @Override

        void addFreeVars(ClassSymbol c) {

            List<VarSymbol> fvs = freevarCache.get(c);

            if (fvs != null) {

                for (List<VarSymbol> l = fvs; l.nonEmpty(); l = l.tail) {

                    addFreeVar(l.head);

                }

            }

        }

        @Override

        void visitSymbol(Symbol _sym) {

            Symbol sym = _sym;

            if (sym.kind == VAR || sym.kind == MTH) {

                if (sym != null && sym.owner != owner)

                    sym = proxies.get(sym);

                if (sym != null && sym.owner == owner) {

                    VarSymbol v = (VarSymbol)sym;

                    if (v.getConstValue() == null) {

                        addFreeVar(v);

                    }

                } else {

                    if (outerThisStack.head != null &&

                        outerThisStack.head != _sym)

                        visitSymbol(outerThisStack.head);

                }

            }

        }

        /** If tree refers to a class instance creation expression

         *  add all free variables of the freshly created class.

         */

        public void visitNewClass(JCNewClass tree) {

            ClassSymbol c = (ClassSymbol)tree.constructor.owner;

            if (tree.encl == null &&

                c.hasOuterInstance() &&

                outerThisStack.head != null)

                visitSymbol(outerThisStack.head);

            super.visitNewClass(tree);

        }

        /** If tree refers to a qualified this or super expression

         *  for anything but the current class, add the outer this

         *  stack as a free variable.

         */

        public void visitSelect(JCFieldAccess tree) {

            if ((tree.name == names._this || tree.name == names._super) &&

                tree.selected.type.tsym != clazz &&

                outerThisStack.head != null)

                visitSymbol(outerThisStack.head);

            super.visitSelect(tree);

        }

        /** If tree refers to a superclass constructor call,

         *  add all free variables of the superclass.

         */

        public void visitApply(JCMethodInvocation tree) {

            if (TreeInfo.name(tree.meth) == names._super) {

                Symbol constructor = TreeInfo.symbol(tree.meth);

                ClassSymbol c = (ClassSymbol)constructor.owner;

                if (c.hasOuterInstance() &&

                    !tree.meth.hasTag(SELECT) &&

                    outerThisStack.head != null)

                    visitSymbol(outerThisStack.head);

            }

            super.visitApply(tree);

        }

    }

    ClassSymbol ownerToCopyFreeVarsFrom(ClassSymbol c) {

        if (!c.isLocal()) {

            return null;

        }

        Symbol currentOwner = c.owner;

        while (currentOwner.owner.kind.matches(KindSelector.TYP) && currentOwner.isLocal()) {

            currentOwner = currentOwner.owner;

        }

        if (currentOwner.owner.kind.matches(KindSelector.VAL_MTH) && c.isSubClass(currentOwner, types)) {

            return (ClassSymbol)currentOwner;

        }

        return null;

    }

    /** Return the variables accessed from within a local class, which

     *  are declared in the local class' owner.

     *  (in reverse order of first access).

     */

    List<VarSymbol> freevars(ClassSymbol c)  {

        List<VarSymbol> fvs = freevarCache.get(c);

        if (fvs != null) {

            return fvs;

        }

        if (c.owner.kind.matches(KindSelector.VAL_MTH)) {

            FreeVarCollector collector = new FreeVarCollector(c);

            collector.scan(classDef(c));

            fvs = collector.fvs;

            freevarCache.put(c, fvs);

            return fvs;

        } else {

            ClassSymbol owner = ownerToCopyFreeVarsFrom(c);

            if (owner != null) {

                fvs = freevarCache.get(owner);

                freevarCache.put(c, fvs);

                return fvs;

            } else {

                return List.nil();

            }

        }

    }

    Map<TypeSymbol,EnumMapping> enumSwitchMap = new LinkedHashMap<>();

    EnumMapping mapForEnum(DiagnosticPosition pos, TypeSymbol enumClass) {

        EnumMapping map = enumSwitchMap.get(enumClass);

        if (map == null)

            enumSwitchMap.put(enumClass, map = new EnumMapping(pos, enumClass));

        return map;

    }

    /** This map gives a translation table to be used for enum

     *  switches.

     *

     *  <p>For each enum that appears as the type of a switch

     *  expression, we maintain an EnumMapping to assist in the

     *  translation, as exemplified by the following example:

     *

     *  <p>we translate

     *  <pre>

     *          switch(colorExpression) {

     *          case red: stmt1;

     *          case green: stmt2;

     *          }

     *  </pre>

     *  into

     *  <pre>

     *          switch(Outer$0.$EnumMap$Color[colorExpression.ordinal()]) {

     *          case 1: stmt1;

     *          case 2: stmt2

     *          }

     *  </pre>

     *  with the auxiliary table initialized as follows:

     *  <pre>

     *          class Outer$0 {

     *              synthetic final int[] $EnumMap$Color = new int[Color.values().length];

     *              static {

     *                  try { $EnumMap$Color[red.ordinal()] = 1; } catch (NoSuchFieldError ex) {}

     *                  try { $EnumMap$Color[green.ordinal()] = 2; } catch (NoSuchFieldError ex) {}

     *              }

     *          }

     *  </pre>

     *  class EnumMapping provides mapping data and support methods for this translation.

     */

    class EnumMapping {

        EnumMapping(DiagnosticPosition pos, TypeSymbol forEnum) {

            this.forEnum = forEnum;

            this.values = new LinkedHashMap<>();

            this.pos = pos;

            Name varName = names

                .fromString(target.syntheticNameChar() +

                            "SwitchMap" +

                            target.syntheticNameChar() +

                            writer.xClassName(forEnum.type).toString()

                            .replace('/', '.')

                            .replace('.', target.syntheticNameChar()));

            ClassSymbol outerCacheClass = outerCacheClass();

            this.mapVar = new VarSymbol(STATIC | SYNTHETIC | FINAL,

                                        varName,

                                        new ArrayType(syms.intType, syms.arrayClass),

                                        outerCacheClass);

            enterSynthetic(pos, mapVar, outerCacheClass.members());

        }

        DiagnosticPosition pos = null;

        // the next value to use

        int next = 1; // 0 (unused map elements) go to the default label

        // the enum for which this is a map

        final TypeSymbol forEnum;

        // the field containing the map

        final VarSymbol mapVar;

        // the mapped values

        final Map<VarSymbol,Integer> values;

        JCLiteral forConstant(VarSymbol v) {

            Integer result = values.get(v);

            if (result == null)

                values.put(v, result = next++);

            return make.Literal(result);

        }

        // generate the field initializer for the map

        void translate() {

            make.at(pos.getStartPosition());