type.java

java编译器gjc源码 java编译环境

/**
 * @(#)Type.java	1.51 03/04/15
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.tools.javac.v8.code;
import com.sun.tools.javac.v8.util.*;

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


/**
 * This class represents GJ types. The class itself defines the behavior of
 *  the following types:
 *
 *  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).
 *
 *  The behavior of the following types is defined in subclasses, which are
 *  all static inner classes of this class:
 *
 *  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),
 *  polymorphic types (tag: FORALL, class: ForAll),
 *  the error type (tag: ERROR, class: ErrorType).
 *
 *  @see TypeTags
 */
public class Type implements Flags, Kinds, TypeTags {

    /**
     * Constant type: no type at all.
     */
    public static final Type noType = new Type(NONE, null);

    /**
     * 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 tag of this type.
     *
     *  @see TypeTags
     */
    public int tag;

    /**
     * The defining class / interface / package / type variable
     */
    public TypeSymbol tsym;

    /**
     * The constant value of this type, null if this type does not have
     *  a constant value attribute. Constant values can be set only for
     *  base types (numbers, booleans) and class types (strings).
     */
    public Object constValue = null;

    /**
     * Define a type given its tag and type symbol
     */
    public Type(int tag, TypeSymbol tsym) {
        super();
        this.tag = tag;
        this.tsym = tsym;
    }

    /**
      * An abstract class for mappings from types to types
      */
    public static abstract class Mapping {

        public Mapping() {
            super();
        }

        public abstract Type apply(Type t);
    }

    /**
      * 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 map(List these, Mapping f) {
        if (these.nonEmpty()) {
            List tail1 = map(these.tail, f);
            Type head1 = f.apply((Type) these.head);
            if (tail1 != these.tail || head1 != these.head)
                return tail1.prepend(head1);
        }
        return these;
    }

    /**
      * Define a constant type, of the same kind as this type
      *  and with given constant value
      */
    public Type constType(Object constValue) {
        assert tag <= BOOLEAN;
        Type t = new Type(tag, tsym);
        t.constValue = constValue;
        return t;
    }

    /**
      * If this is a constant type, return its underlying type.
      *  Otherwise, return the type itself.
      */
    public Type baseType() {
        if (constValue == null)
            return this;
        else
            return tsym.type;
    }

    /**
      * Return the base types of a list of types.
      */
    public static List baseTypes(List types) {
        if (types.nonEmpty()) {
            Type t = ((Type) types.head).baseType();
            List ts = baseTypes(types.tail);
            if (t != types.head || ts != types.tail)
                return new List(t, ts);
        }
        return types;
    }

    /**
      * Convert to string.
      */
    public String toString() {
        String s =
                (tsym == null || tsym.name == null) ? "null" : tsym.name.toString();
        return s;
    }

    /**
      * The Java source which this type represents.  Use of this method
      *  will result in the loss of the plain-language description for
      *  the type.
      */
    public String toJava() {
        String s = (tsym == null || tsym.name == null) ? "null" : tsym.name.toJava();
        return s;
    }

    /**
      * The Java source which this type represents.  A List will always
      *  be represented as a comma-spearated listing of the elements in
      *  that list.  Use of this method will result in the loss of the
      *  plain-language description for the type.
      */
    public static String toJavaList(List list) {
        if (list.isEmpty()) {
            return "";
        } else {
            StringBuffer buf = new StringBuffer();
            buf.append(((Type) list.head).toJava());
            for (List l = list.tail; l.nonEmpty(); l = l.tail) {
                buf.append(",");
                buf.append(((Type) l.head).toJava());
            }
            return buf.toString();
        }
    }

    /**
      * The constant value of this type, converted to String
      *  PRE: Type has a non-null constValue field.
      */
    public String stringValue() {
        if (tag == BOOLEAN)
            return ((Integer) constValue).intValue() == 0 ? "false" : "true";
        else if (tag == CHAR)
            return String.valueOf((char)((Integer) constValue).intValue());
        else
            return constValue.toString();
    }

    /**
      * Is this a constant type whose value is false?
      */
    public boolean isFalse() {
        return tag == BOOLEAN && constValue != null &&
                ((Integer) constValue).intValue() == 0;
    }

    /**
      * Is this a constant type whose value is true?
      */
    public boolean isTrue() {
        return tag == BOOLEAN && constValue != null &&
                ((Integer) constValue).intValue() != 0;
    }

    /**
      * Access methods.
      */
    public List typarams() {
        return emptyList;
    }

    public Type outer() {
        return null;
    }

    public Type elemtype() {
        return null;
    }

    public int dimensions() {
        return 0;
    }

    public List argtypes() {
        return emptyList;
    }

    public Type restype() {
        return null;
    }

    public List thrown() {
        return Type.emptyList;
    }

    public Type bound() {
        return null;
    }

    /**
      * Set the thrown exceptions for a method type.
      */
    public void setThrown(List t) {
        throw new AssertionError();
    }

    /**
      * Navigation methods, these will work for classes, type variables,
      *  foralls, but will return null for arrays and methods.
      */
    public Type supertype() {
        return null;
    }

    public List interfaces() {
        return emptyList;
    }

    /**
      * Return all parameters of this type and all its outer types in order
      *  outer (first) to inner (last).
      */
    public List allparams() {
        return emptyList;
    }

    /**
      * Return the (most specific) base type of this type that starts
      *  with symbol sym.  If none exists, return null.
      */
    public Type asSuper(Symbol sym) {
        return null;
    }

    /**
      * Return the base type of this type or any
      *  of its outer types that starts with symbol sym.
      *  If none exists, return null.
      */
    public Type asOuterSuper(Symbol sym) {
        return null;
    }

    /**
      * If this type is a (possibly selected) type variable,
      *  return the bounding class of this type, otherwise
      *  return the type itself
      */
    public Type classBound() {
        return this;
    }

    /**
      * Return the least specific subtype of this type that starts
      *  with symbol sym. if none exists, return null.
      *  The least specific subtype is determined as follows:
      *
      *  If there is exactly one parameterized instance of sym
      *  that is a subtype of this type, that parameterized instance is returned.
      *  Otherwise, if the plain type or raw type `sym' is a subtype
      *  of this type, the type `sym' itself is returned.
      *  Otherwise, null is returned.
      */
    Type asSub(Symbol sym) {
        return null;
    }

    /**
      * The type of given symbol, seen as a member of this type
      */
    public Type memberType(Symbol sym) {
        return sym.type;
    }

    /**
      * Substitute all occurrences of a type in `from' with the
      *  corresponding type in `to'. Match lists `from' and `to' from the right:
      *  If lists have different length, discard leading elements of the longer list.
      */
    public Type subst(List from, List to) {
        return this;
    }

    public static List subst(List these, List from, List to) {
        if (these.tail != null && from.tail != null) {
            Type head1 = ((Type) these.head).subst(from, to);
            List tail1 = subst(these.tail, from, to);
            if (head1 != these.head || tail1 != these.tail)
                return tail1.prepend(head1);
        }
        return these;
    }

    /**
      * Does this type contain "error" elements?
      */
    public boolean isErroneous() {
        return false;
    }

    public static boolean isErroneous(List ts) {
        for (List l = ts; l.nonEmpty(); l = l.tail)
            if (((Type) 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;
    }