/*

 * Copyright (c) 1999, 2016, 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.lang.annotation.Annotation;

import java.util.ArrayDeque;

import java.util.Collections;

import java.util.EnumMap;

import java.util.Map;

import java.util.function.Function;

import javax.lang.model.type.*;

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

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

import com.sun.tools.javac.comp.Infer.IncorporationAction;

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

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

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

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

/** This class represents Java types. The class itself defines the behavior of

 *  the following types:

 *  <pre>

 *  base types (tags: BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, BOOLEAN),

 *  type `void' (tag: VOID),

 *  the bottom type (tag: BOT),

 *  the missing type (tag: NONE).

 *  </pre>

 *  <p>The behavior of the following types is defined in subclasses, which are

 *  all static inner classes of this class:

 *  <pre>

 *  class types (tag: CLASS, class: ClassType),

 *  array types (tag: ARRAY, class: ArrayType),

 *  method types (tag: METHOD, class: MethodType),

 *  package types (tag: PACKAGE, class: PackageType),

 *  type variables (tag: TYPEVAR, class: TypeVar),

 *  type arguments (tag: WILDCARD, class: WildcardType),

 *  generic method types (tag: FORALL, class: ForAll),

 *  the error type (tag: ERROR, class: ErrorType).

 *  </pre>

 *

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

 *

 *  @see TypeTag

 */

public abstract class Type extends AnnoConstruct implements TypeMirror {

    /**

     * Type metadata,  Should be {@code null} for the default value.

     *

     * Note: it is an invariant that for any {@code TypeMetadata}

     * class, a given {@code Type} may have at most one metadata array

     * entry of that class.

     */

    protected final TypeMetadata metadata;

    public TypeMetadata getMetadata() {

        return metadata;

    }

    public Entry getMetadataOfKind(final Entry.Kind kind) {

        return metadata != null ? metadata.get(kind) : null;

    }

    /** Constant type: no type at all. */

    public static final JCNoType noType = new JCNoType() {

        @Override @DefinedBy(Api.LANGUAGE_MODEL)

        public String toString() {

            return "none";

        }

    };

    /** Constant type: special type to be used during recovery of deferred expressions. */

    public static final JCNoType recoveryType = new JCNoType(){

        @Override @DefinedBy(Api.LANGUAGE_MODEL)

        public String toString() {

            return "recovery";

        }

    };

    /** Constant type: special type to be used for marking stuck trees. */

    public static final JCNoType stuckType = new JCNoType() {

        @Override @DefinedBy(Api.LANGUAGE_MODEL)

        public String toString() {

            return "stuck";

        }

    };

    /** If this switch is turned on, the names of type variables

     *  and anonymous classes are printed with hashcodes appended.

     */

    public static boolean moreInfo = false;

    /** The defining class / interface / package / type variable.

     */

    public TypeSymbol tsym;

    /**

     * Checks if the current type tag is equal to the given tag.

     * @return true if tag is equal to the current type tag.

     */

    public boolean hasTag(TypeTag tag) {

        return tag == getTag();

    }

    /**

     * Returns the current type tag.

     * @return the value of the current type tag.

     */

    public abstract TypeTag getTag();

    public boolean isNumeric() {

        return false;

    }

    public boolean isIntegral() {

        return false;

    }

    public boolean isPrimitive() {

        return false;

    }

    public boolean isPrimitiveOrVoid() {

        return false;

    }

    public boolean isReference() {

        return false;

    }

    public boolean isNullOrReference() {

        return false;

    }

    public boolean isPartial() {

        return false;

    }

    /**

     * The constant value of this type, null if this type does not

     * have a constant value attribute. Only primitive types and

     * strings (ClassType) can have a constant value attribute.

     * @return the constant value attribute of this type

     */

    public Object constValue() {

        return null;

    }

    /** Is this a constant type whose value is false?

     */

    public boolean isFalse() {

        return false;

    }

    /** Is this a constant type whose value is true?

     */

    public boolean isTrue() {

        return false;

    }

    /**

     * Get the representation of this type used for modelling purposes.

     * By default, this is itself. For ErrorType, a different value

     * may be provided.

     */

    public Type getModelType() {

        return this;

    }

    public static List<Type> getModelTypes(List<Type> ts) {

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

        for (Type t: ts)

            lb.append(t.getModelType());

        return lb.toList();

    }

    /**For ErrorType, returns the original type, otherwise returns the type itself.

     */

    public Type getOriginalType() {

        return this;

    }

    public <R,S> R accept(Type.Visitor<R,S> v, S s) { return v.visitType(this, s); }

    /** Define a type given its tag, type symbol, and type annotations

     */

    public Type(TypeSymbol tsym, TypeMetadata metadata) {

        Assert.checkNonNull(metadata);

        this.tsym = tsym;

        this.metadata = metadata;

    }

    /** An abstract class for mappings from types to types

     */

    public static abstract class TypeMapping<S> extends Types.MapVisitor<S> implements Function<Type, Type> {

        @Override

        public Type apply(Type type) {

            return visit(type);

        }

        List<Type> visit(List<Type> ts, S s) {

            return ts.map(t -> visit(t, s));

        }

        @Override

        public Type visitClassType(ClassType t, S s) {

            Type outer = t.getEnclosingType();

            Type outer1 = visit(outer, s);

            List<Type> typarams = t.getTypeArguments();

            List<Type> typarams1 = visit(typarams, s);

            if (outer1 == outer && typarams1 == typarams) return t;

            else return new ClassType(outer1, typarams1, t.tsym, t.metadata) {

                @Override

                protected boolean needsStripping() {

                    return true;

                }

            };

        }

        @Override

        public Type visitWildcardType(WildcardType wt, S s) {

            Type t = wt.type;

            if (t != null)

                t = visit(t, s);

            if (t == wt.type)

                return wt;

            else

                return new WildcardType(t, wt.kind, wt.tsym, wt.bound, wt.metadata) {

                    @Override

                    protected boolean needsStripping() {

                        return true;

                    }

                };

        }

        @Override

        public Type visitArrayType(ArrayType t, S s) {

            Type elemtype = t.elemtype;

            Type elemtype1 = visit(elemtype, s);

            if (elemtype1 == elemtype) return t;

            else return new ArrayType(elemtype1, t.tsym, t.metadata) {

                @Override

                protected boolean needsStripping() {

                    return true;

                }

            };

        }

        @Override

        public Type visitMethodType(MethodType t, S s) {

            List<Type> argtypes = t.argtypes;

            Type restype = t.restype;

            List<Type> thrown = t.thrown;

            List<Type> argtypes1 = visit(argtypes, s);

            Type restype1 = visit(restype, s);

            List<Type> thrown1 = visit(thrown, s);

            if (argtypes1 == argtypes &&

                restype1 == restype &&

                thrown1 == thrown) return t;

            else return new MethodType(argtypes1, restype1, thrown1, t.tsym) {

                @Override

                protected boolean needsStripping() {

                    return true;

                }

            };

        }

        @Override

        public Type visitCapturedType(CapturedType t, S s) {

            return visitTypeVar(t, s);

        }

        @Override

        public Type visitForAll(ForAll t, S s) {

            return visit(t.qtype, s);

        }

    }

    /** map a type function over all immediate descendants of this type

     */

    public <Z> Type map(TypeMapping<Z> mapping, Z arg) {

        return mapping.visit(this, arg);

    }

    /** map a type function over all immediate descendants of this type (no arg version)

     */

    public <Z> Type map(TypeMapping<Z> mapping) {

        return mapping.visit(this, null);

    }

    /** Define a constant type, of the same kind as this type

     *  and with given constant value

     */

    public Type constType(Object constValue) {

        throw new AssertionError();

    }

    /**

     * If this is a constant type, return its underlying type.

     * Otherwise, return the type itself.

     */

    public Type baseType() {

        return this;

    }

    /**

     * Returns the original version of this type, before metadata were added. This routine is meant

     * for internal use only (i.e. {@link Type#equalsIgnoreMetadata(Type)}, {@link Type#stripMetadata});

     * it should not be used outside this class.

     */

    protected Type typeNoMetadata() {

        return metadata == TypeMetadata.EMPTY ? this : baseType();

    }

    /**

     * Create a new copy of this type but with the specified TypeMetadata.

     */

    public abstract Type cloneWithMetadata(TypeMetadata metadata);

    /**

     * Does this type require annotation stripping for API clients?

     */

    protected boolean needsStripping() {

        return false;

    }

    /**

     * Strip all metadata associated with this type - this could return a new clone of the type.

     * This routine is only used to present the correct annotated types back to the users when types

     * are accessed through compiler APIs; it should not be used anywhere in the compiler internals

     * as doing so might result in performance penalties.

     */

    public Type stripMetadataIfNeeded() {

        return needsStripping() ?

                accept(stripMetadata, null) :

                this;

    }

    public Type stripMetadata() {

        return accept(stripMetadata, null);

    }

    //where

        private final static TypeMapping<Void> stripMetadata = new TypeMapping<Void>() {

            @Override

            public Type visitClassType(ClassType t, Void aVoid) {

                return super.visitClassType((ClassType)t.typeNoMetadata(), aVoid);

            }

            @Override

            public Type visitArrayType(ArrayType t, Void aVoid) {

                return super.visitArrayType((ArrayType)t.typeNoMetadata(), aVoid);

            }

            @Override

            public Type visitTypeVar(TypeVar t, Void aVoid) {

                return super.visitTypeVar((TypeVar)t.typeNoMetadata(), aVoid);

            }

            @Override

            public Type visitWildcardType(WildcardType wt, Void aVoid) {

                return super.visitWildcardType((WildcardType)wt.typeNoMetadata(), aVoid);

            }

        };

    public Type annotatedType(final List<Attribute.TypeCompound> annos) {

        final Entry annoMetadata = new TypeMetadata.Annotations(annos);

        return cloneWithMetadata(metadata.combine(annoMetadata));

    }

    public boolean isAnnotated() {

        final TypeMetadata.Annotations metadata =

            (TypeMetadata.Annotations)getMetadataOfKind(Entry.Kind.ANNOTATIONS);

        return null != metadata && !metadata.getAnnotations().isEmpty();

    }

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public List<Attribute.TypeCompound> getAnnotationMirrors() {

        final TypeMetadata.Annotations metadata =

            (TypeMetadata.Annotations)getMetadataOfKind(Entry.Kind.ANNOTATIONS);

        return metadata == null ? List.nil() : metadata.getAnnotations();

    }

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public <A extends Annotation> A getAnnotation(Class<A> annotationType) {

        return null;

    }

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {

        @SuppressWarnings("unchecked")

        A[] tmp = (A[]) java.lang.reflect.Array.newInstance(annotationType, 0);

        return tmp;

    }

    /** Return the base types of a list of types.

     */

    public static List<Type> baseTypes(List<Type> ts) {

        if (ts.nonEmpty()) {

            Type t = ts.head.baseType();

            List<Type> baseTypes = baseTypes(ts.tail);

            if (t != ts.head || baseTypes != ts.tail)

                return baseTypes.prepend(t);

        }

        return ts;

    }

    protected void appendAnnotationsString(StringBuilder sb,

                                         boolean prefix) {

        if (isAnnotated()) {

            if (prefix) {

                sb.append(" ");

            }

            sb.append(getAnnotationMirrors());

            sb.append(" ");

        }

    }

    protected void appendAnnotationsString(StringBuilder sb) {

        appendAnnotationsString(sb, false);

    }

    /** The Java source which this type represents.

     */

    @DefinedBy(Api.LANGUAGE_MODEL)

    public String toString() {

        StringBuilder sb = new StringBuilder();

        appendAnnotationsString(sb);

        if (tsym == null || tsym.name == null) {

            sb.append("<none>");

        } else {

            sb.append(tsym.name);

        }

        if (moreInfo && hasTag(TYPEVAR)) {

            sb.append(hashCode());

        }

        return sb.toString();

    }

    /**

     * The Java source which this type list represents.  A List is

     * represented as a comma-spearated listing of the elements in

     * that list.

     */

    public static String toString(List<Type> ts) {

        if (ts.isEmpty()) {

            return "";

        } else {

            StringBuilder buf = new StringBuilder();

            buf.append(ts.head.toString());

            for (List<Type> l = ts.tail; l.nonEmpty(); l = l.tail)

                buf.append(",").append(l.head.toString());

            return buf.toString();

        }

    }

    /**

     * The constant value of this type, converted to String