/*

 * Copyright (c) 2009, 2015, 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 javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.type.TypeKind;

import javax.tools.JavaFileObject;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * Contains operations specific to processing type annotations.

 * This class has two functions:

 * separate declaration from type annotations and insert the type

 * annotations to their types;

 * and determine the TypeAnnotationPositions for all type annotations.

 */

public class TypeAnnotations {

    protected static final Context.Key<TypeAnnotations> typeAnnosKey = new Context.Key<>();

    public static TypeAnnotations instance(Context context) {

        TypeAnnotations instance = context.get(typeAnnosKey);

        if (instance == null)

            instance = new TypeAnnotations(context);

        return instance;

    }

    final Log log;

    final Names names;

    final Symtab syms;

    final Annotate annotate;

    final Attr attr;

    protected TypeAnnotations(Context context) {

        context.put(typeAnnosKey, this);

        names = Names.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        annotate = Annotate.instance(context);

        attr = Attr.instance(context);

    }

    /**

     * Separate type annotations from declaration annotations and

     * determine the correct positions for type annotations.

     * This version only visits types in signatures and should be

     * called from MemberEnter.

     */

    public void organizeTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {

        annotate.afterTypes(() -> {

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

            try {

                new TypeAnnotationPositions(true).scan(tree);

            } finally {

                log.useSource(oldSource);

            }

        });

    }

    public void validateTypeAnnotationsSignatures(final Env<AttrContext> env, final JCClassDecl tree) {

        annotate.validate(() -> { //validate annotations

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

            try {

                attr.validateTypeAnnotations(tree, true);

            } finally {

                log.useSource(oldSource);

            }

        });

    }

    /**

     * This version only visits types in bodies, that is, field initializers,

     * top-level blocks, and method bodies, and should be called from Attr.

     */

    public void organizeTypeAnnotationsBodies(JCClassDecl tree) {

        new TypeAnnotationPositions(false).scan(tree);

    }

    public enum AnnotationType { DECLARATION, TYPE, NONE, BOTH }

    public List<Attribute> annotationTargets(TypeSymbol tsym) {

        Attribute.Compound atTarget = tsym.getAnnotationTypeMetadata().getTarget();

        if (atTarget == null) {

            return null;

        }

        Attribute atValue = atTarget.member(names.value);

        if (!(atValue instanceof Attribute.Array)) {

            return null;

        }

        List<Attribute> targets = ((Array)atValue).getValue();

        if (targets.stream().anyMatch(a -> !(a instanceof Attribute.Enum))) {

            return null;

        }

        return targets;

    }

    /**

     * Determine whether an annotation is a declaration annotation,

     * a type annotation, or both.

     */

    public AnnotationType annotationTargetType(Attribute.Compound a, Symbol s) {

        List<Attribute> targets = annotationTargets(a.type.tsym);

        return (targets == null) ?

                AnnotationType.DECLARATION :

                targets.stream()

                        .map(attr -> targetToAnnotationType(attr, s))

                        .reduce(AnnotationType.NONE, this::combineAnnotationType);

    }

    private AnnotationType combineAnnotationType(AnnotationType at1, AnnotationType at2) {

        if (at1 == AnnotationType.NONE) {

            return at2;

        } else if (at2 == AnnotationType.NONE) {

            return at1;

        } else if (at1 != at2) {

            return AnnotationType.BOTH;

        } else {

            return at1;

        }

    }

    private AnnotationType targetToAnnotationType(Attribute a, Symbol s) {

        Attribute.Enum e = (Attribute.Enum)a;

        if (e.value.name == names.TYPE) {

            if (s.kind == TYP)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.FIELD) {

            if (s.kind == VAR &&

                    s.owner.kind != MTH)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.METHOD) {

            if (s.kind == MTH &&

                    !s.isConstructor())

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.PARAMETER) {

            if (s.kind == VAR &&

                    s.owner.kind == MTH &&

                    (s.flags() & Flags.PARAMETER) != 0)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.CONSTRUCTOR) {

            if (s.kind == MTH &&

                    s.isConstructor())

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.LOCAL_VARIABLE) {

            if (s.kind == VAR &&

                    s.owner.kind == MTH &&

                    (s.flags() & Flags.PARAMETER) == 0)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.ANNOTATION_TYPE) {

            if (s.kind == TYP &&

                    (s.flags() & Flags.ANNOTATION) != 0)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.PACKAGE) {

            if (s.kind == PCK)

                return AnnotationType.DECLARATION;

        } else if (e.value.name == names.TYPE_USE) {

            if (s.kind == TYP ||

                    s.kind == VAR ||

                    (s.kind == MTH && !s.isConstructor() &&

                    !s.type.getReturnType().hasTag(TypeTag.VOID)) ||

                    (s.kind == MTH && s.isConstructor()))

                return AnnotationType.TYPE;

        } else if (e.value.name == names.TYPE_PARAMETER) {

            /* Irrelevant in this case */

            // TYPE_PARAMETER doesn't aid in distinguishing between

            // Type annotations and declaration annotations on an

            // Element

        } else {

            Assert.error("annotationTargetType(): unrecognized Attribute name " + e.value.name +

                    " (" + e.value.name.getClass() + ")");

            return AnnotationType.DECLARATION;

        }

        return AnnotationType.NONE;

    }

    private class TypeAnnotationPositions extends TreeScanner {

        private final boolean sigOnly;

        TypeAnnotationPositions(boolean sigOnly) {

            this.sigOnly = sigOnly;

        }

        /*

         * When traversing the AST we keep the "frames" of visited

         * trees in order to determine the position of annotations.

         */

        private List<JCTree> frames = List.nil();

        protected void push(JCTree t) {

            frames = frames.prepend(t);

        }

        protected JCTree pop() {

            JCTree t = frames.head;

            frames = frames.tail;

            return t;

            }

        // could this be frames.elems.tail.head?

        private JCTree peek2() {

            return frames.tail.head;

        }

        @Override

        public void scan(JCTree tree) {

            push(tree);

            try {

                super.scan(tree);

            } finally {

                pop();

            }

        }

        /**

         * Separates type annotations from declaration annotations.

         * This step is needed because in certain locations (where declaration

         * and type annotations can be mixed, e.g. the type of a field)

         * we never build an JCAnnotatedType. This step finds these

         * annotations and marks them as if they were part of the type.

         */

        private void separateAnnotationsKinds(JCTree typetree, Type type,

                                              Symbol sym, TypeAnnotationPosition pos)

        {

            List<Attribute.Compound> allAnnotations = sym.getRawAttributes();

            ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<>();

            ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<>();

            ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<>();

            for (Attribute.Compound a : allAnnotations) {

                switch (annotationTargetType(a, sym)) {

                    case DECLARATION:

                        declAnnos.append(a);

                        break;

                    case BOTH: {

                        declAnnos.append(a);

                        Attribute.TypeCompound ta = toTypeCompound(a, pos);

                        typeAnnos.append(ta);

                        break;

                    }

                    case TYPE: {

                        Attribute.TypeCompound ta = toTypeCompound(a, pos);

                        typeAnnos.append(ta);

                        // Also keep track which annotations are only type annotations

                        onlyTypeAnnos.append(ta);

                        break;

                    }

                }

            }

            // If we have no type annotations we are done for this Symbol

            if (typeAnnos.isEmpty()) {

                return;

            }

            // Reset decl annotations to the set {all - type only}

            sym.resetAnnotations();

            sym.setDeclarationAttributes(declAnnos.toList());

            List<Attribute.TypeCompound> typeAnnotations = typeAnnos.toList();

            if (type == null) {

                // When type is null, put the type annotations to the symbol.

                // This is used for constructor return annotations, for which

                // we use the type of the enclosing class.

                type = sym.getEnclosingElement().asType();

                // Declaration annotations are always allowed on constructor returns.

                // Therefore, use typeAnnotations instead of onlyTypeAnnos.

                typeWithAnnotations(typetree, type, typeAnnotations, typeAnnotations, pos);

                // Note that we don't use the result, the call to

                // typeWithAnnotations side-effects the type annotation positions.

                // This is important for constructors of nested classes.

                sym.appendUniqueTypeAttributes(typeAnnotations);

                return;

            }

            // type is non-null, add type annotations from declaration context to the type

            type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList(), pos);

            if (sym.getKind() == ElementKind.METHOD) {

                sym.type.asMethodType().restype = type;

            } else if (sym.getKind() == ElementKind.PARAMETER && currentLambda == null) {

                sym.type = type;

                if (sym.getQualifiedName().equals(names._this)) {

                    sym.owner.type.asMethodType().recvtype = type;

                    // note that the typeAnnotations will also be added to the owner below.

                } else {

                    MethodType methType = sym.owner.type.asMethodType();

                    List<VarSymbol> params = ((MethodSymbol)sym.owner).params;

                    List<Type> oldArgs = methType.argtypes;

                    ListBuffer<Type> newArgs = new ListBuffer<>();

                    while (params.nonEmpty()) {

                        if (params.head == sym) {

                            newArgs.add(type);

                        } else {

                            newArgs.add(oldArgs.head);

                        }

                        oldArgs = oldArgs.tail;

                        params = params.tail;

                    }

                    methType.argtypes = newArgs.toList();

                }

            } else {

                sym.type = type;

            }

            sym.appendUniqueTypeAttributes(typeAnnotations);

            if (sym.getKind() == ElementKind.PARAMETER ||

                sym.getKind() == ElementKind.LOCAL_VARIABLE ||

                sym.getKind() == ElementKind.RESOURCE_VARIABLE ||

                sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {

                // Make sure all type annotations from the symbol are also

                // on the owner. If the owner is an initializer block, propagate

                // to the type.

                final long ownerFlags = sym.owner.flags();

                if ((ownerFlags & Flags.BLOCK) != 0) {

                    // Store init and clinit type annotations with the ClassSymbol

                    // to allow output in Gen.normalizeDefs.

                    ClassSymbol cs = (ClassSymbol) sym.owner.owner;

                    if ((ownerFlags & Flags.STATIC) != 0) {

                        cs.appendClassInitTypeAttributes(typeAnnotations);

                    } else {

                        cs.appendInitTypeAttributes(typeAnnotations);

                    }

                } else {

                    sym.owner.appendUniqueTypeAttributes(sym.getRawTypeAttributes());

                }

            }

        }

        // This method has a similar purpose as

        // {@link com.sun.tools.javac.parser.JavacParser.insertAnnotationsToMostInner(JCExpression, List<JCTypeAnnotation>, boolean)}

        // We found a type annotation in a declaration annotation position,

        // for example, on the return type.

        // Such an annotation is _not_ part of an JCAnnotatedType tree and we therefore

        // need to set its position explicitly.

        // The method returns a copy of type that contains these annotations.

        //

        // As a side effect the method sets the type annotation position of "annotations".

        // Note that it is assumed that all annotations share the same position.

        private Type typeWithAnnotations(final JCTree typetree, final Type type,

                final List<Attribute.TypeCompound> annotations,

                final List<Attribute.TypeCompound> onlyTypeAnnotations,

                final TypeAnnotationPosition pos)

        {

            if (annotations.isEmpty()) {

                return type;

            }

            if (type.hasTag(TypeTag.ARRAY))

                return rewriteArrayType((ArrayType)type, annotations, pos);

            if (type.hasTag(TypeTag.TYPEVAR)) {

                return type.annotatedType(onlyTypeAnnotations);

            } else if (type.getKind() == TypeKind.UNION) {

                // There is a TypeKind, but no TypeTag.

                JCTypeUnion tutree = (JCTypeUnion)typetree;

                JCExpression fst = tutree.alternatives.get(0);

                Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations, pos);

                fst.type = res;

                // TODO: do we want to set res as first element in uct.alternatives?

                // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;

                // Return the un-annotated union-type.

                return type;

            } else {

                Type enclTy = type;

                Element enclEl = type.asElement();

                JCTree enclTr = typetree;

                while (enclEl != null &&

                        enclEl.getKind() != ElementKind.PACKAGE &&

                        enclTy != null &&

                        enclTy.getKind() != TypeKind.NONE &&

                        enclTy.getKind() != TypeKind.ERROR &&

                        (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT ||

                                enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE ||

                                enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) {

                    // Iterate also over the type tree, not just the type: the type is already

                    // completely resolved and we cannot distinguish where the annotation

                    // belongs for a nested type.

                    if (enclTr.getKind() == JCTree.Kind.MEMBER_SELECT) {

                        // only change encl in this case.

                        enclTy = enclTy.getEnclosingType();

                        enclEl = enclEl.getEnclosingElement();

                        enclTr = ((JCFieldAccess)enclTr).getExpression();

                    } else if (enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE) {

                        enclTr = ((JCTypeApply)enclTr).getType();

                    } else {

                        // only other option because of while condition

                        enclTr = ((JCAnnotatedType)enclTr).getUnderlyingType();

                    }

                }

                /** We are trying to annotate some enclosing type,

                 * but nothing more exists.

                 */

                if (enclTy != null &&

                        enclTy.hasTag(TypeTag.NONE)) {

                    switch (onlyTypeAnnotations.size()) {

                        case 0:

                            // Don't issue an error if all type annotations are

                            // also declaration annotations.

                            // If the annotations are also declaration annotations, they are

                            // illegal as type annotations but might be legal as declaration annotations.

                            // The normal declaration annotation checks make sure that the use is valid.

                            break;

                        case 1:

                            log.error(typetree.pos(), "cant.type.annotate.scoping.1",

                                    onlyTypeAnnotations);

                            break;

                        default:

                            log.error(typetree.pos(), "cant.type.annotate.scoping",

                                    onlyTypeAnnotations);

                    }

                    return type;

                }

                // At this point we have visited the part of the nested

                // type that is written in the source code.

                // Now count from here to the actual top-level class to determine

                // the correct nesting.

                // The genericLocation for the annotation.

                ListBuffer<TypePathEntry> depth = new ListBuffer<>();

                Type topTy = enclTy;

                while (enclEl != null &&

                        enclEl.getKind() != ElementKind.PACKAGE &&

                        topTy != null &&

                        topTy.getKind() != TypeKind.NONE &&

                        topTy.getKind() != TypeKind.ERROR) {

                    topTy = topTy.getEnclosingType();

                    enclEl = enclEl.getEnclosingElement();

                    if (topTy != null && topTy.getKind() != TypeKind.NONE) {

                        // Only count enclosing types.

                        depth = depth.append(TypePathEntry.INNER_TYPE);

                    }

                }