/*

 * Copyright (c) 2003, 2017, 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 com.sun.tools.javac.code.*;

import com.sun.tools.javac.code.Attribute.Compound;

import com.sun.tools.javac.code.Attribute.TypeCompound;

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

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

import com.sun.tools.javac.code.TypeMetadata.Entry.Kind;

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

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

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

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

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

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

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

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

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

import javax.tools.JavaFileObject;

import java.util.*;

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

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

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

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

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

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

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

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

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

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

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

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

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

/** Enter annotations onto symbols and types (and trees).

 *

 *  This is also a pseudo stage in the compiler taking care of scheduling when annotations are

 *  entered.

 *

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

    protected static final Context.Key<Annotate> annotateKey = new Context.Key<>();

    public static Annotate instance(Context context) {

        Annotate instance = context.get(annotateKey);

        if (instance == null)

            instance = new Annotate(context);

        return instance;

    }

    private final Attr attr;

    private final Check chk;

    private final ConstFold cfolder;

    private final DeferredLintHandler deferredLintHandler;

    private final Enter enter;

    private final Lint lint;

    private final Log log;

    private final Names names;

    private final Resolve resolve;

    private final TreeMaker make;

    private final Symtab syms;

    private final TypeEnvs typeEnvs;

    private final Types types;

    private final Attribute theUnfinishedDefaultValue;

    private final boolean allowRepeatedAnnos;

    private final String sourceName;

    protected Annotate(Context context) {

        context.put(annotateKey, this);

        attr = Attr.instance(context);

        chk = Check.instance(context);

        cfolder = ConstFold.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        enter = Enter.instance(context);

        log = Log.instance(context);

        lint = Lint.instance(context);

        make = TreeMaker.instance(context);

        names = Names.instance(context);

        resolve = Resolve.instance(context);

        syms = Symtab.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        types = Types.instance(context);

        theUnfinishedDefaultValue =  new Attribute.Error(syms.errType);

        Source source = Source.instance(context);

        allowRepeatedAnnos = source.allowRepeatedAnnotations();

        sourceName = source.name;

        blockCount = 1;

    }

    /** Semaphore to delay annotation processing */

    private int blockCount = 0;

    /** Called when annotations processing needs to be postponed. */

    public void blockAnnotations() {

        blockCount++;

    }

    /** Called when annotation processing can be resumed. */

    public void unblockAnnotations() {

        blockCount--;

        if (blockCount == 0)

            flush();

    }

    /** Variant which allows for a delayed flush of annotations.

     * Needed by ClassReader */

    public void unblockAnnotationsNoFlush() {

        blockCount--;

    }

    /** are we blocking annotation processing? */

    public boolean annotationsBlocked() {return blockCount > 0; }

    public void enterDone() {

        unblockAnnotations();

    }

    public List<TypeCompound> fromAnnotations(List<JCAnnotation> annotations) {

        if (annotations.isEmpty()) {

            return List.nil();

        }

        ListBuffer<TypeCompound> buf = new ListBuffer<>();

        for (JCAnnotation anno : annotations) {

            Assert.checkNonNull(anno.attribute);

            buf.append((TypeCompound) anno.attribute);

        }

        return buf.toList();

    }

    /** Annotate (used for everything else) */

    public void normal(Runnable r) {

        q.append(r);

    }

    /** Validate, triggers after 'normal' */

    public void validate(Runnable a) {

        validateQ.append(a);

    }

    /** Flush all annotation queues */

    public void flush() {

        if (annotationsBlocked()) return;

        if (isFlushing()) return;

        startFlushing();

        try {

            while (q.nonEmpty()) {

                q.next().run();

            }

            while (typesQ.nonEmpty()) {

                typesQ.next().run();

            }

            while (afterTypesQ.nonEmpty()) {

                afterTypesQ.next().run();

            }

            while (validateQ.nonEmpty()) {

                validateQ.next().run();

            }

        } finally {

            doneFlushing();

        }

    }

    private ListBuffer<Runnable> q = new ListBuffer<>();

    private ListBuffer<Runnable> validateQ = new ListBuffer<>();

    private int flushCount = 0;

    private boolean isFlushing() { return flushCount > 0; }

    private void startFlushing() { flushCount++; }

    private void doneFlushing() { flushCount--; }

    ListBuffer<Runnable> typesQ = new ListBuffer<>();

    ListBuffer<Runnable> afterTypesQ = new ListBuffer<>();

    public void typeAnnotation(Runnable a) {

        typesQ.append(a);

    }

    public void afterTypes(Runnable a) {

        afterTypesQ.append(a);

    }

    /**

     * Queue annotations for later attribution and entering. This is probably the method you are looking for.

     *

     * @param annotations the list of JCAnnotations to attribute and enter

     * @param localEnv    the enclosing env

     * @param s           ths Symbol on which to enter the annotations

     * @param deferPos    report errors here

     */

    public void annotateLater(List<JCAnnotation> annotations, Env<AttrContext> localEnv,

            Symbol s, DiagnosticPosition deferPos)

    {

        if (annotations.isEmpty()) {

            return;

        }

        s.resetAnnotations(); // mark Annotations as incomplete for now

        normal(() -> {

            // Packages are unusual, in that they are the only type of declaration that can legally appear

            // more than once in a compilation, and in all cases refer to the same underlying symbol.

            // This means they are the only kind of declaration that syntactically may have multiple sets

            // of annotations, each on a different package declaration, even though that is ultimately

            // forbidden by JLS 8 section 7.4.

            // The corollary here is that all of the annotations on a package symbol may have already

            // been handled, meaning that the set of annotations pending completion is now empty.

            Assert.check(s.kind == PCK || s.annotationsPendingCompletion());

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

            DiagnosticPosition prevLintPos =

                    deferPos != null

                            ? deferredLintHandler.setPos(deferPos)

                            : deferredLintHandler.immediate();

            Lint prevLint = deferPos != null ? null : chk.setLint(lint);

            try {

                if (s.hasAnnotations() && annotations.nonEmpty())

                    log.error(annotations.head.pos, "already.annotated", Kinds.kindName(s), s);

                Assert.checkNonNull(s, "Symbol argument to actualEnterAnnotations is null");

                // false is passed as fifth parameter since annotateLater is

                // never called for a type parameter

                annotateNow(s, annotations, localEnv, false, false);

            } finally {

                if (prevLint != null)

                    chk.setLint(prevLint);

                deferredLintHandler.setPos(prevLintPos);

                log.useSource(prev);

            }

        });

        validate(() -> { //validate annotations

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

            try {

                chk.validateAnnotations(annotations, s);

            } finally {

                log.useSource(prev);

            }

        });

    }

    /** Queue processing of an attribute default value. */

    public void annotateDefaultValueLater(JCExpression defaultValue, Env<AttrContext> localEnv,

            MethodSymbol m, DiagnosticPosition deferPos)

    {

        normal(() -> {

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

            DiagnosticPosition prevLintPos = deferredLintHandler.setPos(deferPos);

            try {

                enterDefaultValue(defaultValue, localEnv, m);

            } finally {

                deferredLintHandler.setPos(prevLintPos);

                log.useSource(prev);

            }

        });

        validate(() -> { //validate annotations

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

            try {

                // if default value is an annotation, check it is a well-formed

                // annotation value (e.g. no duplicate values, no missing values, etc.)

                chk.validateAnnotationTree(defaultValue);

            } finally {

                log.useSource(prev);

            }

        });

    }

    /** Enter a default value for an annotation element. */

    private void enterDefaultValue(JCExpression defaultValue,

            Env<AttrContext> localEnv, MethodSymbol m) {

        m.defaultValue = attributeAnnotationValue(m.type.getReturnType(), defaultValue, localEnv);

    }

    /**

     * Gather up annotations into a map from type symbols to lists of Compound attributes,

     * then continue on with repeating annotations processing.

     */

    private <T extends Attribute.Compound> void annotateNow(Symbol toAnnotate,

            List<JCAnnotation> withAnnotations, Env<AttrContext> env, boolean typeAnnotations,

            boolean isTypeParam)

    {

        Map<TypeSymbol, ListBuffer<T>> annotated = new LinkedHashMap<>();

        Map<T, DiagnosticPosition> pos = new HashMap<>();

        for (List<JCAnnotation> al = withAnnotations; !al.isEmpty(); al = al.tail) {

            JCAnnotation a = al.head;

            T c;

            if (typeAnnotations) {

                @SuppressWarnings("unchecked")

                T tmp = (T)attributeTypeAnnotation(a, syms.annotationType, env);

                c = tmp;

            } else {

                @SuppressWarnings("unchecked")

                T tmp = (T)attributeAnnotation(a, syms.annotationType, env);

                c = tmp;

            }

            Assert.checkNonNull(c, "Failed to create annotation");

            if (annotated.containsKey(a.type.tsym)) {

                if (!allowRepeatedAnnos) {

                    log.error(DiagnosticFlag.SOURCE_LEVEL, a.pos(), "repeatable.annotations.not.supported.in.source", sourceName);

                }

                ListBuffer<T> l = annotated.get(a.type.tsym);

                l = l.append(c);

                annotated.put(a.type.tsym, l);

                pos.put(c, a.pos());

            } else {

                annotated.put(a.type.tsym, ListBuffer.of(c));

                pos.put(c, a.pos());

            }

            // Note: @Deprecated has no effect on local variables and parameters

            if (!c.type.isErroneous()

                    && (toAnnotate.kind == MDL || toAnnotate.owner.kind != MTH)

                    && types.isSameType(c.type, syms.deprecatedType)) {

                toAnnotate.flags_field |= (Flags.DEPRECATED | Flags.DEPRECATED_ANNOTATION);

                Attribute fr = c.member(names.forRemoval);

                if (fr instanceof Attribute.Constant) {

                    Attribute.Constant v = (Attribute.Constant) fr;

                    if (v.type == syms.booleanType && ((Integer) v.value) != 0) {

                        toAnnotate.flags_field |= Flags.DEPRECATED_REMOVAL;

                    }

                }

            }

        }

        List<T> buf = List.nil();

        for (ListBuffer<T> lb : annotated.values()) {

            if (lb.size() == 1) {

                buf = buf.prepend(lb.first());

            } else {

                AnnotationContext<T> ctx = new AnnotationContext<>(env, annotated, pos, typeAnnotations);

                T res = makeContainerAnnotation(lb.toList(), ctx, toAnnotate, isTypeParam);

                if (res != null)

                    buf = buf.prepend(res);

            }

        }

        if (typeAnnotations) {

            @SuppressWarnings("unchecked")

            List<TypeCompound> attrs = (List<TypeCompound>)buf.reverse();

            toAnnotate.appendUniqueTypeAttributes(attrs);

        } else {

            @SuppressWarnings("unchecked")

            List<Attribute.Compound> attrs =  (List<Attribute.Compound>)buf.reverse();

            toAnnotate.resetAnnotations();

            toAnnotate.setDeclarationAttributes(attrs);

        }

    }

    /**

     * Attribute and store a semantic representation of the annotation tree {@code tree} into the

     * tree.attribute field.

     *

     * @param tree the tree representing an annotation

     * @param expectedAnnotationType the expected (super)type of the annotation

     * @param env the current env in where the annotation instance is found

     */

    public Attribute.Compound attributeAnnotation(JCAnnotation tree, Type expectedAnnotationType,

                                                  Env<AttrContext> env)

    {

        // The attribute might have been entered if it is Target or Repetable

        // Because TreeCopier does not copy type, redo this if type is null

        if (tree.attribute != null && tree.type != null)

            return tree.attribute;

        List<Pair<MethodSymbol, Attribute>> elems = attributeAnnotationValues(tree, expectedAnnotationType, env);

        Attribute.Compound ac = new Attribute.Compound(tree.type, elems);

        return tree.attribute = ac;

    }

    /** Attribute and store a semantic representation of the type annotation tree {@code tree} into

     * the tree.attribute field.

     *

     * @param a the tree representing an annotation

     * @param expectedAnnotationType the expected (super)type of the annotation

     * @param env the the current env in where the annotation instance is found

     */

    public Attribute.TypeCompound attributeTypeAnnotation(JCAnnotation a, Type expectedAnnotationType,

                                                          Env<AttrContext> env)

    {

        // The attribute might have been entered if it is Target or Repetable

        // Because TreeCopier does not copy type, redo this if type is null

        if (a.attribute == null || a.type == null || !(a.attribute instanceof Attribute.TypeCompound)) {

            // Create a new TypeCompound

            List<Pair<MethodSymbol,Attribute>> elems =

                    attributeAnnotationValues(a, expectedAnnotationType, env);

            Attribute.TypeCompound tc =

                    new Attribute.TypeCompound(a.type, elems, TypeAnnotationPosition.unknown);

            a.attribute = tc;

            return tc;

        } else {

            // Use an existing TypeCompound

            return (Attribute.TypeCompound)a.attribute;

        }

    }

    /**

     *  Attribute annotation elements creating a list of pairs of the Symbol representing that

     *  element and the value of that element as an Attribute. */

    private List<Pair<MethodSymbol, Attribute>> attributeAnnotationValues(JCAnnotation a,

            Type expected, Env<AttrContext> env)

    {

        // The annotation might have had its type attributed (but not

        // checked) by attr.attribAnnotationTypes during MemberEnter,

        // in which case we do not need to do it again.

        Type at = (a.annotationType.type != null ?

                a.annotationType.type : attr.attribType(a.annotationType, env));

        a.type = chk.checkType(a.annotationType.pos(), at, expected);

        boolean isError = a.type.isErroneous();

        if (!a.type.tsym.isAnnotationType() && !isError) {

            log.error(a.annotationType.pos(),

                    "not.annotation.type", a.type.toString());

            isError = true;

        }

        // List of name=value pairs (or implicit "value=" if size 1)

        List<JCExpression> args = a.args;

        boolean elidedValue = false;

        // special case: elided "value=" assumed

        if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {

            args.head = make.at(args.head.pos).

                    Assign(make.Ident(names.value), args.head);

            elidedValue = true;

        }

        ListBuffer<Pair<MethodSymbol,Attribute>> buf = new ListBuffer<>();

        for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {

            Pair<MethodSymbol, Attribute> p = attributeAnnotationNameValuePair(tl.head, a.type, isError, env, elidedValue);

            if (p != null && !p.fst.type.isErroneous())

                buf.append(p);

        }

        return buf.toList();

    }

    // where

    private Pair<MethodSymbol, Attribute> attributeAnnotationNameValuePair(JCExpression nameValuePair,

            Type thisAnnotationType, boolean badAnnotation, Env<AttrContext> env, boolean elidedValue)

    {

        if (!nameValuePair.hasTag(ASSIGN)) {

            log.error(nameValuePair.pos(), "annotation.value.must.be.name.value");

            attributeAnnotationValue(nameValuePair.type = syms.errType, nameValuePair, env);

            return null;

        }