/*

 * Copyright (c) 1999, 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.code;

import java.lang.annotation.Annotation;

import java.util.Collections;

import java.util.EnumMap;

import java.util.EnumSet;

import java.util.Map;

import java.util.Set;

import javax.lang.model.type.*;

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

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 TypeMetadata.Element getMetadataOfKind(final TypeMetadata.Element.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 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 Mapping {

        private String name;

        public Mapping(String name) {

            this.name = name;

        }

        public abstract Type apply(Type t);

        public String toString() {

            return name;

        }

    }

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

     */

    public Type map(Mapping f) {

        return this;

    }

    /** map a type function over a list of types

     */

    public static List<Type> map(List<Type> ts, Mapping f) {

        if (ts.nonEmpty()) {

            List<Type> tail1 = map(ts.tail, f);

            Type t = f.apply(ts.head);

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

                return tail1.prepend(t);

        }

        return ts;

    }

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

    }

    /**

     * Create a new type with exactly the given metadata.  The

     * argument is guaranteed to always be non-empty, and should have

     * already been copied/combined with the current type's metadata.

     * This is used internally by other methods.

     *

     */

    public abstract Type clone(TypeMetadata md);

    public Type combineMetadata(final TypeMetadata.Element md) {

        return clone(metadata.combine(md));

    }

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

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

        return combineMetadata(annoMetadata);

    }

    public boolean isAnnotated() {

        final TypeMetadata.Annotations metadata =

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

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

    }

    private static final List<Attribute.TypeCompound> noAnnotations = List.nil();

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public List<Attribute.TypeCompound> getAnnotationMirrors() {

        final TypeMetadata.Annotations metadata =

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

        return metadata == null ? noAnnotations : 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

     */

    public String stringValue() {

        Object cv = Assert.checkNonNull(constValue());

        return cv.toString();

    }

    /**

     * This method is analogous to isSameType, but weaker, since we

     * never complete classes. Where isSameType would complete a

     * class, equals assumes that the two types are different.

     */

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public boolean equals(Object t) {

        return super.equals(t);

    }

    @Override @DefinedBy(Api.LANGUAGE_MODEL)

    public int hashCode() {

        return super.hashCode();

    }

    public String argtypes(boolean varargs) {

        List<Type> args = getParameterTypes();

        if (!varargs) return args.toString();

        StringBuilder buf = new StringBuilder();

        while (args.tail.nonEmpty()) {

            buf.append(args.head);

            args = args.tail;

            buf.append(',');

        }

        if (args.head.hasTag(ARRAY)) {

            buf.append(((ArrayType)args.head).elemtype);

            if (args.head.getAnnotationMirrors().nonEmpty()) {

                buf.append(args.head.getAnnotationMirrors());

            }

            buf.append("...");

        } else {

            buf.append(args.head);

        }

        return buf.toString();

    }

    /** Access methods.

     */

    public List<Type>        getTypeArguments()  { return List.nil(); }

    public Type              getEnclosingType()  { return null; }

    public List<Type>        getParameterTypes() { return List.nil(); }

    public Type              getReturnType()     { return null; }

    public Type              getReceiverType()   { return null; }

    public List<Type>        getThrownTypes()    { return List.nil(); }

    public Type              getUpperBound()     { return null; }

    public Type              getLowerBound()     { return null; }

    /** Navigation methods, these will work for classes, type variables,

     *  foralls, but will return null for arrays and methods.

     */

   /** Return all parameters of this type and all its outer types in order

    *  outer (first) to inner (last).

    */

    public List<Type> allparams() { return List.nil(); }

    /** Does this type contain "error" elements?

     */

    public boolean isErroneous() {

        return false;

    }

    public static boolean isErroneous(List<Type> ts) {

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

            if (l.head.isErroneous()) return true;

        return false;

    }

    /** Is this type parameterized?

     *  A class type is parameterized if it has some parameters.

     *  An array type is parameterized if its element type is parameterized.

     *  All other types are not parameterized.

     */

    public boolean isParameterized() {

        return false;

    }

    /** Is this type a raw type?

     *  A class type is a raw type if it misses some of its parameters.

     *  An array type is a raw type if its element type is raw.

     *  All other types are not raw.

     *  Type validation will ensure that the only raw types

     *  in a program are types that miss all their type variables.

     */

    public boolean isRaw() {

        return false;

    }

    public boolean isCompound() {

        return tsym.completer == null

            // Compound types can't have a completer.  Calling

            // flags() will complete the symbol causing the

            // compiler to load classes unnecessarily.  This led

            // to regression 6180021.

            && (tsym.flags() & COMPOUND) != 0;

    }

    public boolean isInterface() {

        return (tsym.flags() & INTERFACE) != 0;

    }

    public boolean isFinal() {

        return (tsym.flags() & FINAL) != 0;

    }

    /**

     * Does this type contain occurrences of type t?

     */

    public boolean contains(Type t) {

        return t == this;

    }

    public static boolean contains(List<Type> ts, Type t) {

        for (List<Type> l = ts;

             l.tail != null /*inlined: l.nonEmpty()*/;

             l = l.tail)

            if (l.head.contains(t)) return true;

        return false;

    }

    /** Does this type contain an occurrence of some type in 'ts'?

     */