/*

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

import java.util.LinkedHashMap;

import java.util.Map;

import javax.lang.model.element.ElementKind;

import javax.lang.model.type.TypeKind;

import javax.tools.JavaFileObject;

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

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

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

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

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

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

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

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

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

/** Enter annotations on symbols.  Annotations accumulate in a queue,

 *  which is processed at the top level of any set of recursive calls

 *  requesting it be processed.

 *

 *  <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 TreeMaker make;

    private final Log log;

    private final Symtab syms;

    private final Names names;

    private final Resolve rs;

    private final Types types;

    private final ConstFold cfolder;

    private final Check chk;

    private final Lint lint;

    private final DeferredLintHandler deferredLintHandler;

    private final Source source;

    private boolean allowTypeAnnos;

    private boolean allowRepeatedAnnos;

    protected Annotate(Context context) {

        context.put(annotateKey, this);

        attr = Attr.instance(context);

        make = TreeMaker.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        names = Names.instance(context);

        rs = Resolve.instance(context);

        types = Types.instance(context);

        cfolder = ConstFold.instance(context);

        chk = Check.instance(context);

        source = Source.instance(context);

        lint = Lint.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        allowRepeatedAnnos = source.allowRepeatedAnnotations();

        allowTypeAnnos = source.allowTypeAnnotations();

    }

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

 * Queue maintenance

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

    private int enterCount = 0;

    ListBuffer<Worker> q = new ListBuffer<>();

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

    ListBuffer<Worker> repeatedQ = new ListBuffer<>();

    ListBuffer<Worker> afterRepeatedQ = new ListBuffer<>();

    ListBuffer<Worker> validateQ = new ListBuffer<>();

    public void earlier(Worker a) {

        q.prepend(a);

    }

    public void normal(Worker a) {

        q.append(a);

    }

    public void typeAnnotation(Worker a) {

        typesQ.append(a);

    }

    public void repeated(Worker a) {

        repeatedQ.append(a);

    }

    public void afterRepeated(Worker a) {

        afterRepeatedQ.append(a);

    }

    public void validate(Worker a) {

        validateQ.append(a);

    }

    /** Called when the Enter phase starts. */

    public void enterStart() {

        enterCount++;

    }

    /** Called after the Enter phase completes. */

    public void enterDone() {

        enterCount--;

        flush();

    }

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

     * Needed by ClassReader */

    public void enterDoneWithoutFlush() {

        enterCount--;

    }

    public void flush() {

        if (enterCount != 0) return;

        enterCount++;

        try {

            while (q.nonEmpty()) {

                q.next().run();

            }

            while (typesQ.nonEmpty()) {

                typesQ.next().run();

            }

            while (repeatedQ.nonEmpty()) {

                repeatedQ.next().run();

            }

            while (afterRepeatedQ.nonEmpty()) {

                afterRepeatedQ.next().run();

            }

            while (validateQ.nonEmpty()) {

                validateQ.next().run();

            }

        } finally {

            enterCount--;

        }

    }

    /** A client that needs to run during {@link #flush()} registers an worker

     *  into one of the queues defined in this class. The queues are: {@link #earlier(Worker)},

     *  {@link #normal(Worker)}, {@link #typeAnnotation(Worker)}, {@link #repeated(Worker)},

     *  {@link #afterRepeated(Worker)}, {@link #validate(Worker)}.

     *  The {@link Worker#run()} method will called inside the {@link #flush()}

     *  call. Queues are empties in the abovementioned order.

     */

    public interface Worker {

        void run();

        String toString();

    }

    /**

     * This context contains all the information needed to synthesize new

     * annotations trees by the completer for repeating annotations.

     */

    private class AnnotationContext<T extends Attribute.Compound> {

        public final Env<AttrContext> env;

        public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;

        public final Map<T, JCDiagnostic.DiagnosticPosition> pos;

        public final boolean isTypeCompound;

        public AnnotationContext(Env<AttrContext> env,

                                 Map<Symbol.TypeSymbol, ListBuffer<T>> annotated,

                                 Map<T, JCDiagnostic.DiagnosticPosition> pos,

                                 boolean isTypeCompound) {

            Assert.checkNonNull(env);

            Assert.checkNonNull(annotated);

            Assert.checkNonNull(pos);

            this.env = env;

            this.annotated = annotated;

            this.pos = pos;

            this.isTypeCompound = isTypeCompound;

        }

        public String toString() {

            StringBuilder sb = new StringBuilder();

            sb.append("RepeatedContext[");

            for (Map.Entry<Symbol.TypeSymbol, ListBuffer<T>> entry :

                     annotated.entrySet()) {

                sb.append(" ");

                sb.append(entry.getKey());

                sb.append(" = { ");

                sb.append(entry.getValue());

                sb.append(" }");

            }

            sb.append(" ]");

            return sb.toString();

        }

    }

    private static class Placeholder<T extends Attribute.Compound> extends Attribute.Compound {

        private final Annotate.AnnotationContext<T> ctx;

        private final List<T> placeholderFor;

        private final Symbol on;

        public Placeholder(Annotate.AnnotationContext<T> ctx,

                           List<T> placeholderFor, Symbol on) {

            super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),

                  placeholderFor.head.position);

            this.ctx = ctx;

            this.placeholderFor = placeholderFor;

            this.on = on;

        }

        @Override

        public String toString() {

            return "<placeholder: " + placeholderFor + " on: " + on + ">";

    }

        public List<T> getPlaceholderFor() {

            return placeholderFor;

        }

        public Annotate.AnnotationContext<T> getRepeatedContext() {

            return ctx;

        }

    }

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

 * Compute an attribute from its annotation.

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

    /**

     * Enter (and attribute) a single regular annotation, returning

     * its Attribute.  We give these annotations a position in case we

     * end up creating a type annotation from using toTypeCompound.

     *

     * In some cases, namely on annotations that can never be type

     * annotations (like package annotations), the position can be

     * null; however, if this annotation is in a place where it might

     * possibly denote a type annotation, it will have a non-null

     * position.

     *

     * @param a Annotation to attribute.

     * @param expected Expected annotation type.

     * @param env The environment.

     * @param position The type annotation position this will have if

     *                 it's converted to a type annotation.

     * @return The Attribute.Compound representing this annotation.

     */

    Attribute.Compound enterAnnotation(JCAnnotation a,

                                       Type expected,

                                       Env<AttrContext> env,

                                       TypeAnnotationPosition position) {

        List<Pair<MethodSymbol,Attribute>> buf =

            enterAttributeValues(a, expected, env, position);

        Attribute.Compound ac =

            new Attribute.Compound(a.type, buf, position);

        a.attribute = ac;

        return ac;

    }

    /**

     * Enter (and attribute) a single type annotation, returning its

     * Attribute.

     *

     * Things are a bit complicated, though, because a single source

     * annotation (JCAnnotation) might give rise to several bytecode

     * annotations (Attribute.TypeCompound), but we can only associate

     * a source annotation with one bytecode annotation.  Thus, we

     * have to distinguish between the "primary" (which will be stored

     * to the JCAnnotation) and "secondary" (which won't) annotations.

     * The primary place this gets used is for anonymous classes.

     *

     * The annotations we generate for the new instruction are the

     * primary, and the ones we generate for the class are the

     * secondaries.  (Note: this choice is arbitrary, and it does not

     * appear to cause any problems if these roles are reversed)

     *

     * @param a The annotation to attribute.

     * @param expected The expected annotation type.

     * @param env The environment.

     * @param position The type annotation position to give the type

     *                 annotation.

     * @param secondaryAttr Whether or not this is a secondary (ie

     *                      will ignore the .attribute field on a).

     * @return The Attribute.TypeCompound representing the annotation.

     */

    Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,

                                               Type expected,

                                               Env<AttrContext> env,

                                               TypeAnnotationPosition position,

                                               boolean secondaryAttr) {

        List<Pair<MethodSymbol,Attribute>> buf =

            enterAttributeValues(a, expected, env, position);

        // Secondary attr means we do not set the .attribute field of

        // the JCAnnotation, nor do we pay attention to it.

        if (!secondaryAttr || a.attribute == null ||

            !(a.attribute instanceof Attribute.TypeCompound)) {

            // Create a new TypeCompound

            Attribute.TypeCompound tc =

                new Attribute.TypeCompound(a.type, buf, position);

            a.attribute = tc;

            return tc;

        } else {

            // Use an existing TypeCompound

            return (Attribute.TypeCompound)a.attribute;

        }

    }

    // Attribute all the annotation's values.

    private List<Pair<MethodSymbol,Attribute>>

            enterAttributeValues(JCAnnotation a,

                                 Type expected,

                                 Env<AttrContext> env,

                                 TypeAnnotationPosition position) {

        // 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.flags() & Flags.ANNOTATION) == 0 && !isError) {

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

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

            isError = true;

        }

        List<JCExpression> args = a.args;

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

            // special case: elided "value=" assumed

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

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

        }

        ListBuffer<Pair<MethodSymbol,Attribute>> buf =

            new ListBuffer<>();

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

            JCExpression t = tl.head;

            if (!t.hasTag(ASSIGN)) {

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

                enterAttributeValue(t.type = syms.errType, t, env, position);

                continue;

            }

            JCAssign assign = (JCAssign)t;

            if (!assign.lhs.hasTag(IDENT)) {

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

                enterAttributeValue(t.type = syms.errType, t, env, position);

                continue;

            }

            JCIdent left = (JCIdent)assign.lhs;

            Symbol method = rs.resolveQualifiedMethod(assign.rhs.pos(),

                                                          env,

                                                          a.type,

                                                          left.name,

                                                          List.<Type>nil(),

                                                          null);

            left.sym = method;

            left.type = method.type;

            if (method.owner != a.type.tsym && !isError)

                log.error(left.pos(), "no.annotation.member", left.name, a.type);

            Type result = method.type.getReturnType();

            Attribute value = enterAttributeValue(result, assign.rhs, env, position);

            if (!method.type.isErroneous())

                buf.append(new Pair<>((MethodSymbol)method, value));

            t.type = result;

        }

        return buf.toList();

    }

    Attribute enterAttributeValue(Type expected,

                                  JCExpression tree,

                                  Env<AttrContext> env) {

        return enterAttributeValue(expected, tree, env, null);

    }

    Attribute enterAttributeValue(Type expected,

                                  JCExpression tree,

                                  Env<AttrContext> env,

                                  TypeAnnotationPosition position) {

        //first, try completing the attribution value sym - if a completion

        //error is thrown, we should recover gracefully, and display an

        //ordinary resolution diagnostic.

        try {

            expected.tsym.complete();

        } catch(CompletionFailure e) {

            log.error(tree.pos(), "cant.resolve", Kinds.kindName(e.sym), e.sym);

            expected = syms.errType;

        }

        if (expected.hasTag(ARRAY)) {

            if (!tree.hasTag(NEWARRAY)) {

                tree = make.at(tree.pos).

                    NewArray(null, List.<JCExpression>nil(), List.of(tree));

            }

            JCNewArray na = (JCNewArray)tree;

            if (na.elemtype != null) {

                log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");

            }

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

            for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {

                buf.append(enterAttributeValue(types.elemtype(expected),

                                               l.head, env, position));

            }

            na.type = expected;

            return new Attribute.

                Array(expected, buf.toArray(new Attribute[buf.length()]));

        }

        if (tree.hasTag(NEWARRAY)) { //error recovery

            if (!expected.isErroneous())

                log.error(tree.pos(), "annotation.value.not.allowable.type");

            JCNewArray na = (JCNewArray)tree;

            if (na.elemtype != null) {

                log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");

            }

            for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {

                enterAttributeValue(syms.errType, l.head, env, position);

            }

            return new Attribute.Error(syms.errType);

        }

        if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {

            if (tree.hasTag(ANNOTATION)) {

                return enterAnnotation((JCAnnotation)tree, expected, env, position);

            } else {

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

                expected = syms.errType;

            }

        }

        if (tree.hasTag(ANNOTATION)) { //error recovery

            if (!expected.isErroneous())

                log.error(tree.pos(), "annotation.not.valid.for.type", expected);

            enterAnnotation((JCAnnotation)tree, syms.errType, env, position);

            return new Attribute.Error(((JCAnnotation)tree).annotationType.type);

        }

        if (expected.isPrimitive() ||

            (types.isSameType(expected, syms.stringType) && !expected.hasTag(TypeTag.ERROR))) {

            Type result = attr.attribExpr(tree, env, expected);

            if (result.isErroneous())

                return new Attribute.Error(result.getOriginalType());

            if (result.constValue() == null) {

                log.error(tree.pos(), "attribute.value.must.be.constant");

                return new Attribute.Error(expected);

            }

            result = cfolder.coerce(result, expected);

            return new Attribute.Constant(expected, result.constValue());

        }

        if (expected.tsym == syms.classType.tsym) {

            Type result = attr.attribExpr(tree, env, expected);

            if (result.isErroneous()) {

                // Does it look like an unresolved class literal?

                if (TreeInfo.name(tree) == names._class &&

                    ((JCFieldAccess) tree).selected.type.isErroneous()) {

                    Name n = (((JCFieldAccess) tree).selected).type.tsym.flatName();

                    return new Attribute.UnresolvedClass(expected,

                            types.createErrorType(n,

                                    syms.unknownSymbol, syms.classType));

                } else {

                    return new Attribute.Error(result.getOriginalType());

                }

            }

            // Class literals look like field accesses of a field named class

            // at the tree level