/*

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

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import javax.lang.model.element.ElementVisitor;

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

import com.sun.tools.javac.code.Source.Feature;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.sun.tools.javac.code.Types.UniqueType;

import com.sun.tools.javac.comp.Modules;

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

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

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

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

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

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

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

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

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

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

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

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

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

/** A class that defines all predefined constants and operators

 *  as well as special classes such as java.lang.Object, which need

 *  to be known to the compiler. All symbols are held in instance

 *  fields. This makes it possible to work in multiple concurrent

 *  projects, which might use different class files for library classes.

 *

 *  <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 Symtab {

    /** The context key for the symbol table. */

    protected static final Context.Key<Symtab> symtabKey = new Context.Key<>();

    /** Get the symbol table instance. */

    public static Symtab instance(Context context) {

        Symtab instance = context.get(symtabKey);

        if (instance == null)

            instance = new Symtab(context);

        return instance;

    }

    /** Builtin types.

     */

    public final JCPrimitiveType byteType = new JCPrimitiveType(BYTE, null);

    public final JCPrimitiveType charType = new JCPrimitiveType(CHAR, null);

    public final JCPrimitiveType shortType = new JCPrimitiveType(SHORT, null);

    public final JCPrimitiveType intType = new JCPrimitiveType(INT, null);

    public final JCPrimitiveType longType = new JCPrimitiveType(LONG, null);

    public final JCPrimitiveType floatType = new JCPrimitiveType(FLOAT, null);

    public final JCPrimitiveType doubleType = new JCPrimitiveType(DOUBLE, null);

    public final JCPrimitiveType booleanType = new JCPrimitiveType(BOOLEAN, null);

    public final Type botType = new BottomType();

    public final JCVoidType voidType = new JCVoidType();

    private final Names names;

    private final JavacMessages messages;

    private final Completer initialCompleter;

    private final Completer moduleCompleter;

    /** A symbol for the unnamed module.

     */

    public final ModuleSymbol unnamedModule;

    /** The error module.

     */

    public final ModuleSymbol errModule;

    /** A symbol for no module, for use with -source 8 or less

     */

    public final ModuleSymbol noModule;

    /** A symbol for the root package.

     */

    public final PackageSymbol rootPackage;

    /** A symbol that stands for a missing symbol.

     */

    public final TypeSymbol noSymbol;

    /** The error symbol.

     */

    public final ClassSymbol errSymbol;

    /** The unknown symbol.

     */

    public final ClassSymbol unknownSymbol;

    /** A value for the errType, with a originalType of noType */

    public final Type errType;

    /** A value for the unknown type. */

    public final Type unknownType;

    /** The builtin type of all arrays. */

    public final ClassSymbol arrayClass;

    public final MethodSymbol arrayCloneMethod;

    /** VGJ: The (singleton) type of all bound types. */

    public final ClassSymbol boundClass;

    /** The builtin type of all methods. */

    public final ClassSymbol methodClass;

    /** A symbol for the java.base module.

     */

    public final ModuleSymbol java_base;

    /** Predefined types.

     */

    public final Type objectType;

    public final Type objectsType;

    public final Type classType;

    public final Type classLoaderType;

    public final Type stringType;

    public final Type stringBufferType;

    public final Type stringBuilderType;

    public final Type cloneableType;

    public final Type serializableType;

    public final Type serializedLambdaType;

    public final Type varHandleType;

    public final Type methodHandleType;

    public final Type methodHandleLookupType;

    public final Type methodTypeType;

    public final Type nativeHeaderType;

    public final Type throwableType;

    public final Type errorType;

    public final Type interruptedExceptionType;

    public final Type illegalArgumentExceptionType;

    public final Type exceptionType;

    public final Type runtimeExceptionType;

    public final Type classNotFoundExceptionType;

    public final Type noClassDefFoundErrorType;

    public final Type noSuchFieldErrorType;

    public final Type assertionErrorType;

    public final Type incompatibleClassChangeErrorType;

    public final Type cloneNotSupportedExceptionType;

    public final Type annotationType;

    public final TypeSymbol enumSym;

    public final Type listType;

    public final Type collectionsType;

    public final Type comparableType;

    public final Type comparatorType;

    public final Type arraysType;

    public final Type iterableType;

    public final Type iteratorType;

    public final Type annotationTargetType;

    public final Type overrideType;

    public final Type retentionType;

    public final Type deprecatedType;

    public final Type suppressWarningsType;

    public final Type supplierType;

    public final Type inheritedType;

    public final Type profileType;

    public final Type proprietaryType;

    public final Type systemType;

    public final Type autoCloseableType;

    public final Type trustMeType;

    public final Type lambdaMetafactory;

    public final Type stringConcatFactory;

    public final Type repeatableType;

    public final Type documentedType;

    public final Type elementTypeType;

    public final Type functionalInterfaceType;

    /** The symbol representing the length field of an array.

     */

    public final VarSymbol lengthVar;

    /** The symbol representing the final finalize method on enums */

    public final MethodSymbol enumFinalFinalize;

    /** The symbol representing the close method on TWR AutoCloseable type */

    public final MethodSymbol autoCloseableClose;

    /** The predefined type that belongs to a tag.

     */

    public final Type[] typeOfTag = new Type[TypeTag.getTypeTagCount()];

    /** The name of the class that belongs to a basic type tag.

     */

    public final Name[] boxedName = new Name[TypeTag.getTypeTagCount()];

    /** A hashtable containing the encountered top-level and member classes,

     *  indexed by flat names. The table does not contain local classes.

     *  It should be updated from the outside to reflect classes defined

     *  by compiled source files.

     */

    private final Map<Name, Map<ModuleSymbol,ClassSymbol>> classes = new HashMap<>();

    /** A hashtable containing the encountered packages.

     *  the table should be updated from outside to reflect packages defined

     *  by compiled source files.

     */

    private final Map<Name, Map<ModuleSymbol,PackageSymbol>> packages = new HashMap<>();

    /** A hashtable giving the encountered modules.

     */

    private final Map<Name, ModuleSymbol> modules = new LinkedHashMap<>();

    private final Map<Types.UniqueType, VarSymbol> classFields = new HashMap<>();

    public VarSymbol getClassField(Type type, Types types) {

        return classFields.computeIfAbsent(

            new UniqueType(type, types), k -> {

                Type arg = null;

                if (type.getTag() == ARRAY || type.getTag() == CLASS)

                    arg = types.erasure(type);

                else if (type.isPrimitiveOrVoid())

                    arg = types.boxedClass(type).type;

                else

                    throw new AssertionError(type);

                Type t = new ClassType(

                    classType.getEnclosingType(), List.of(arg), classType.tsym);

                return new VarSymbol(

                    STATIC | PUBLIC | FINAL, names._class, t, type.tsym);

            });

    }

    public void initType(Type type, ClassSymbol c) {

        type.tsym = c;

        typeOfTag[type.getTag().ordinal()] = type;

    }

    public void initType(Type type, String name) {

        initType(

            type,

            new ClassSymbol(

                PUBLIC, names.fromString(name), type, rootPackage));

    }

    public void initType(Type type, String name, String bname) {

        initType(type, name);

        boxedName[type.getTag().ordinal()] = names.fromString("java.lang." + bname);

    }

    /** The class symbol that owns all predefined symbols.

     */

    public final ClassSymbol predefClass;

    /** Enter a class into symbol table.

     *  @param s The name of the class.

     */

    private Type enterClass(String s) {

        return enterClass(java_base, names.fromString(s)).type;

    }

    public void synthesizeEmptyInterfaceIfMissing(final Type type) {

        final Completer completer = type.tsym.completer;

        type.tsym.completer = new Completer() {

            @Override

            public void complete(Symbol sym) throws CompletionFailure {

                try {

                    completer.complete(sym);

                } catch (CompletionFailure e) {

                    sym.flags_field |= (PUBLIC | INTERFACE);

                    ((ClassType) sym.type).supertype_field = objectType;

                }

            }

            @Override

            public boolean isTerminal() {

                return completer.isTerminal();

            }

        };

    }

    public void synthesizeBoxTypeIfMissing(final Type type) {

        ClassSymbol sym = enterClass(java_base, boxedName[type.getTag().ordinal()]);

        final Completer completer = sym.completer;

        sym.completer = new Completer() {

            @Override

            public void complete(Symbol sym) throws CompletionFailure {

                try {

                    completer.complete(sym);

                } catch (CompletionFailure e) {

                    sym.flags_field |= PUBLIC;

                    ((ClassType) sym.type).supertype_field = objectType;

                    MethodSymbol boxMethod =

                        new MethodSymbol(PUBLIC | STATIC, names.valueOf,

                                         new MethodType(List.of(type), sym.type,

                                List.nil(), methodClass),

                            sym);

                    sym.members().enter(boxMethod);

                    MethodSymbol unboxMethod =

                        new MethodSymbol(PUBLIC,

                            type.tsym.name.append(names.Value), // x.intValue()

                            new MethodType(List.nil(), type,

                                List.nil(), methodClass),

                            sym);

                    sym.members().enter(unboxMethod);

                }

            }

            @Override

            public boolean isTerminal() {

                return completer.isTerminal();

            }

        };

    }

    // Enter a synthetic class that is used to mark classes in ct.sym.

    // This class does not have a class file.

    private Type enterSyntheticAnnotation(String name) {

        // for now, leave the module null, to prevent problems from synthesizing the

        // existence of a class in any specific module, including noModule

        ClassType type = (ClassType)enterClass(java_base, names.fromString(name)).type;

        ClassSymbol sym = (ClassSymbol)type.tsym;

        sym.completer = Completer.NULL_COMPLETER;

        sym.flags_field = PUBLIC|ACYCLIC|ANNOTATION|INTERFACE;

        sym.erasure_field = type;

        sym.members_field = WriteableScope.create(sym);

        type.typarams_field = List.nil();

        type.allparams_field = List.nil();

        type.supertype_field = annotationType;

        type.interfaces_field = List.nil();

        return type;

    }

    /** Constructor; enters all predefined identifiers and operators

     *  into symbol table.

     */

    protected Symtab(Context context) throws CompletionFailure {

        context.put(symtabKey, this);

        names = Names.instance(context);

        // Create the unknown type

        unknownType = new UnknownType();

        messages = JavacMessages.instance(context);

        MissingInfoHandler missingInfoHandler = MissingInfoHandler.instance(context);

        rootPackage = new RootPackageSymbol(names.empty, null, missingInfoHandler);

        // create the basic builtin symbols

        unnamedModule = new ModuleSymbol(names.empty, null) {

                {

                    directives = List.nil();

                    exports = List.nil();

                    provides = List.nil();

                    uses = List.nil();

                    ModuleSymbol java_base = enterModule(names.java_base);

                    com.sun.tools.javac.code.Directive.RequiresDirective d =

                            new com.sun.tools.javac.code.Directive.RequiresDirective(java_base,

                                    EnumSet.of(com.sun.tools.javac.code.Directive.RequiresFlag.MANDATED));

                    requires = List.of(d);

                }

                @Override

                public String toString() {

                    return messages.getLocalizedString("compiler.misc.unnamed.module");

                }

            };

        addRootPackageFor(unnamedModule);

        unnamedModule.enclosedPackages = unnamedModule.enclosedPackages.prepend(unnamedModule.unnamedPackage);

        errModule = new ModuleSymbol(names.empty, null) {

                {

                    directives = List.nil();

                    exports = List.nil();

                    provides = List.nil();

                    uses = List.nil();

                    ModuleSymbol java_base = enterModule(names.java_base);

                    com.sun.tools.javac.code.Directive.RequiresDirective d =

                            new com.sun.tools.javac.code.Directive.RequiresDirective(java_base,

                                    EnumSet.of(com.sun.tools.javac.code.Directive.RequiresFlag.MANDATED));

                    requires = List.of(d);

                }

            };

        addRootPackageFor(errModule);

        noModule = new ModuleSymbol(names.empty, null) {

            @Override public boolean isNoModule() {

                return true;

            }

        };

        addRootPackageFor(noModule);

        noSymbol = new TypeSymbol(NIL, 0, names.empty, Type.noType, rootPackage) {

            @Override @DefinedBy(Api.LANGUAGE_MODEL)

            public <R, P> R accept(ElementVisitor<R, P> v, P p) {

                return v.visitUnknown(this, p);

            }

        };

        // create the error symbols

        errSymbol = new ClassSymbol(PUBLIC|STATIC|ACYCLIC, names.any, null, rootPackage);

        errType = new ErrorType(errSymbol, Type.noType);

        unknownSymbol = new ClassSymbol(PUBLIC|STATIC|ACYCLIC, names.fromString("<any?>"), null, rootPackage);

        unknownSymbol.members_field = new Scope.ErrorScope(unknownSymbol);

        unknownSymbol.type = unknownType;

        // initialize builtin types

        initType(byteType, "byte", "Byte");

        initType(shortType, "short", "Short");

        initType(charType, "char", "Character");

        initType(intType, "int", "Integer");

        initType(longType, "long", "Long");

        initType(floatType, "float", "Float");

        initType(doubleType, "double", "Double");

        initType(booleanType, "boolean", "Boolean");

        initType(voidType, "void", "Void");

        initType(botType, "<nulltype>");

        initType(errType, errSymbol);

        initType(unknownType, unknownSymbol);

        // the builtin class of all arrays

        arrayClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Array, noSymbol);

        // VGJ

        boundClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Bound, noSymbol);

        boundClass.members_field = new Scope.ErrorScope(boundClass);

        // the builtin class of all methods

        methodClass = new ClassSymbol(PUBLIC|ACYCLIC, names.Method, noSymbol);

        methodClass.members_field = new Scope.ErrorScope(boundClass);

        // Create class to hold all predefined constants and operations.

        predefClass = new ClassSymbol(PUBLIC|ACYCLIC, names.empty, rootPackage);

        WriteableScope scope = WriteableScope.create(predefClass);

        predefClass.members_field = scope;

        // Get the initial completer for Symbols from the ClassFinder

        initialCompleter = ClassFinder.instance(context).getCompleter();

        rootPackage.members_field = WriteableScope.create(rootPackage);

        // Enter symbols for basic types.

        scope.enter(byteType.tsym);

        scope.enter(shortType.tsym);

        scope.enter(charType.tsym);

        scope.enter(intType.tsym);

        scope.enter(longType.tsym);

        scope.enter(floatType.tsym);

        scope.enter(doubleType.tsym);

        scope.enter(booleanType.tsym);

        scope.enter(errType.tsym);

        // Enter symbol for the errSymbol

        scope.enter(errSymbol);

        Source source = Source.instance(context);

        if (Feature.MODULES.allowedInSource(source)) {