/*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

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

    // Class cannot be instantiated.

    private TypeAnnotations() {}

    /**

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

     * The method returns the Annotator object that should be added

     * to the correct Annotate queue for later processing.

     */

    public static Annotator organizeTypeAnnotationsSignatures(final Symtab syms, final Names names,

            final Log log, final JCClassDecl tree) {

        return new Annotator() {

            @Override

            public void enterAnnotation() {

                new TypeAnnotationPositions(syms, names, log, true).scan(tree);

            }

        };

    }

    /**

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

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

     */

    public static void organizeTypeAnnotationsBodies(Symtab syms, Names names, Log log, JCClassDecl tree) {

        new TypeAnnotationPositions(syms, names, log, false).scan(tree);

    }

    private static class TypeAnnotationPositions extends TreeScanner {

        private enum AnnotationType { DECLARATION, TYPE, BOTH };

        private final Symtab syms;

        private final Names names;

        private final Log log;

        private final boolean sigOnly;

        private TypeAnnotationPositions(Symtab syms, Names names, Log log, boolean sigOnly) {

            this.syms = syms;

            this.names = names;

            this.log = log;

            this.sigOnly = sigOnly;

        }

        /*

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

         * trees in order to determine the position of annotations.

         */

        private ListBuffer<JCTree> frames = ListBuffer.lb();

        protected void push(JCTree t) { frames = frames.prepend(t); }

        protected JCTree pop() { return frames.next(); }

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

        private JCTree peek2() { return frames.toList().tail.head; }

        @Override

        public void scan(JCTree tree) {

            push(tree);

            super.scan(tree);

            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) {

            /*

            System.out.printf("separateAnnotationsKinds(typetree: %s, type: %s, symbol: %s, pos: %s%n",

                    typetree, type, sym, pos);

            */

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

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

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

            for (Attribute.Compound a : annotations) {

                switch (annotationType(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);

                    break;

                }

                }

            }

            sym.annotations.reset();

            sym.annotations.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

                // no appropriate type exists.

                sym.annotations.appendUniqueTypes(typeAnnotations);

                return;

            }

            // type is non-null and annotations are added to that type

            type = typeWithAnnotations(typetree, type, typeAnnotations, log);

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

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

            } else {

                sym.type = type;

            }

            sym.annotations.appendUniqueTypes(typeAnnotations);

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

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

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

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

            }

            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.

                sym.owner.annotations.appendUniqueTypes(sym.getTypeAnnotationMirrors());

            }

        }

        // 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.

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

                final List<Attribute.TypeCompound> annotations, Log log) {

            // System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s)%n",

            //         typetree, type, annotations);

            if (annotations.isEmpty()) {

                return type;

            }

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

                Type toreturn;

                Type.ArrayType tomodify;

                Type.ArrayType arType;

                {

                    Type touse = type;

                    if (type.getKind() == TypeKind.ANNOTATED) {

                        Type.AnnotatedType atype = (Type.AnnotatedType)type;

                        toreturn = new Type.AnnotatedType(atype.underlyingType);

                        ((Type.AnnotatedType)toreturn).typeAnnotations = atype.typeAnnotations;

                        touse = atype.underlyingType;

                        arType = (Type.ArrayType) touse;

                        tomodify = new Type.ArrayType(null, arType.tsym);

                        ((Type.AnnotatedType)toreturn).underlyingType = tomodify;

                    } else {

                        arType = (Type.ArrayType) touse;

                        tomodify = new Type.ArrayType(null, arType.tsym);

                        toreturn = tomodify;

                    }

                }

                JCArrayTypeTree arTree = arrayTypeTree(typetree);

                ListBuffer<TypePathEntry> depth = ListBuffer.lb();

                depth = depth.append(TypePathEntry.ARRAY);

                while (arType.elemtype.hasTag(TypeTag.ARRAY)) {

                    if (arType.elemtype.getKind() == TypeKind.ANNOTATED) {

                        Type.AnnotatedType aelemtype = (Type.AnnotatedType) arType.elemtype;

                        Type.AnnotatedType newAT = new Type.AnnotatedType(aelemtype.underlyingType);

                        tomodify.elemtype = newAT;

                        newAT.typeAnnotations = aelemtype.typeAnnotations;

                        arType = (Type.ArrayType) aelemtype.underlyingType;

                        tomodify = new Type.ArrayType(null, arType.tsym);

                        newAT.underlyingType = tomodify;

                    } else {

                        arType = (Type.ArrayType) arType.elemtype;

                        tomodify.elemtype = new Type.ArrayType(null, arType.tsym);

                        tomodify = (Type.ArrayType) tomodify.elemtype;

                    }

                    arTree = arrayTypeTree(arTree.elemtype);

                    depth = depth.append(TypePathEntry.ARRAY);

                }

                Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations, log);

                tomodify.elemtype = arelemType;

                for (Attribute.TypeCompound a : annotations) {

                    TypeAnnotationPosition p = a.position;

                    p.location = p.location.prependList(depth.toList());

                }

                return toreturn;

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

                // Nothing to do for type variables.

                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.getKind() == TypeKind.NONE &&

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

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

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

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

                    // TODO: also if it's "java. @A lang.Object", that is,

                    // if it's on a package?

                    log.error(enclTr.pos(), "cant.annotate.nested.type", enclTr.toString());

                    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 = ListBuffer.lb();

                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);

                    }

                }

                if (depth.nonEmpty()) {

                    // Only need to change the annotation positions

                    // if they are on an enclosed type.

                    for (Attribute.TypeCompound a : annotations) {

                        TypeAnnotationPosition p = a.position;

                        p.location = p.location.appendList(depth.toList());

                    }

                }

                Type ret = typeWithAnnotations(type, enclTy, annotations);

                return ret;

            }

        }

        private static JCArrayTypeTree arrayTypeTree(JCTree typetree) {

            if (typetree.getKind() == JCTree.Kind.ARRAY_TYPE) {

                return (JCArrayTypeTree) typetree;

            } else if (typetree.getKind() == JCTree.Kind.ANNOTATED_TYPE) {

                return (JCArrayTypeTree) ((JCAnnotatedType)typetree).underlyingType;

            } else {

                Assert.error("Could not determine array type from type tree: " + typetree);

                return null;

            }

        }

        /** Return a copy of the first type that only differs by

         * inserting the annotations to the left-most/inner-most type

         * or the type given by stopAt.

         *

         * We need the stopAt parameter to know where on a type to

         * put the annotations.

         * If we have nested classes Outer > Middle > Inner, and we

         * have the source type "@A Middle.Inner", we will invoke

         * this method with type = Outer.Middle.Inner,

         * stopAt = Middle.Inner, and annotations = @A.

         *

         * @param type The type to copy.

         * @param stopAt The type to stop at.

         * @param annotations The annotations to insert.

         * @return A copy of type that contains the annotations.

         */

        private static Type typeWithAnnotations(final Type type,

                final Type stopAt,

                final List<Attribute.TypeCompound> annotations) {

            Visitor<Type, List<TypeCompound>> visitor =

                    new Type.Visitor<Type, List<Attribute.TypeCompound>>() {

                @Override

                public Type visitClassType(ClassType t, List<TypeCompound> s) {

                    // assert that t.constValue() == null?

                    if (t == stopAt ||

                        t.getEnclosingType() == Type.noType) {

                        return new AnnotatedType(s, t);

                    } else {

                        ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),

                                t.typarams_field, t.tsym);

                        ret.all_interfaces_field = t.all_interfaces_field;

                        ret.allparams_field = t.allparams_field;

                        ret.interfaces_field = t.interfaces_field;

                        ret.rank_field = t.rank_field;

                        ret.supertype_field = t.supertype_field;

                        return ret;

                    }

                }

                @Override

                public Type visitAnnotatedType(AnnotatedType t, List<TypeCompound> s) {

                    return new AnnotatedType(t.typeAnnotations, t.underlyingType.accept(this, s));

                }

                @Override

                public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {

                    return new AnnotatedType(s, t);

                }

                @Override

                public Type visitArrayType(ArrayType t, List<TypeCompound> s) {

                    ArrayType ret = new ArrayType(t.elemtype.accept(this, s), t.tsym);

                    return ret;

                }

                @Override

                public Type visitMethodType(MethodType t, List<TypeCompound> s) {

                    // Impossible?

                    return t;

                }

                @Override

                public Type visitPackageType(PackageType t, List<TypeCompound> s) {

                    // Impossible?

                    return t;

                }

                @Override

                public Type visitTypeVar(TypeVar t, List<TypeCompound> s) {

                    return new AnnotatedType(s, t);

                }

                @Override

                public Type visitCapturedType(CapturedType t, List<TypeCompound> s) {

                    return new AnnotatedType(s, t);

                }

                @Override

                public Type visitForAll(ForAll t, List<TypeCompound> s) {

                    // Impossible?

                    return t;

                }

                @Override

                public Type visitUndetVar(UndetVar t, List<TypeCompound> s) {

                    // Impossible?

                    return t;

                }

                @Override

                public Type visitErrorType(ErrorType t, List<TypeCompound> s) {

                    return new AnnotatedType(s, t);

                }

                @Override

                public Type visitType(Type t, List<TypeCompound> s) {

                    // Error?

                    return t;

                }

            };

            return type.accept(visitor, annotations);

        }

        private static Attribute.TypeCompound toTypeCompound(Attribute.Compound a, TypeAnnotationPosition p) {

            // It is safe to alias the position.

            return new Attribute.TypeCompound(a, p);

        }

        private AnnotationType annotationType(Attribute.Compound a, Symbol s) {

            Attribute.Compound atTarget =

                a.type.tsym.attribute(syms.annotationTargetType.tsym);

            if (atTarget == null) {

                return inferTargetMetaInfo(a, s);

            }

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

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

                Assert.error("annotationType(): bad @Target argument " + atValue +

                        " (" + atValue.getClass() + ")");

                return AnnotationType.DECLARATION; // error recovery

            }

            Attribute.Array arr = (Attribute.Array) atValue;

            boolean isDecl = false, isType = false;

            for (Attribute app : arr.values) {

                if (!(app instanceof Attribute.Enum)) {

                    Assert.error("annotationType(): unrecognized Attribute kind " + app +

                            " (" + app.getClass() + ")");

                    isDecl = true;

                    continue;

                }

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

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

                    if (s.kind == Kinds.TYP)

                        isDecl = true;

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

                    if (s.kind == Kinds.VAR &&

                            s.owner.kind != Kinds.MTH)

                        isDecl = true;

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

                    if (s.kind == Kinds.MTH &&

                            !s.isConstructor())

                        isDecl = true;

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

                    if (s.kind == Kinds.VAR &&

                            s.owner.kind == Kinds.MTH &&

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

                        isDecl = true;

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

                    if (s.kind == Kinds.MTH &&

                            s.isConstructor())

                        isDecl = true;

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

                    if (s.kind == Kinds.VAR &&

                            s.owner.kind == Kinds.MTH &&

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

                        isDecl = true;

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

                    if (s.kind == Kinds.TYP &&

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

                        isDecl = true;