TypeBinding.java

/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;

import java.util.List;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;

/*
 * Not all fields defined by this type (& its subclasses) are initialized when it is created.
 * Some are initialized only when needed.
 *
 * Accessors have been provided for some public fields so all TypeBindings have the same API...
 * but access public fields directly whenever possible.
 * Non-public fields have accessors which should be used everywhere you expect the field to be initialized.
 *
 * null is NOT a valid value for a non-public field... it just means the field is not initialized.
 */
abstract public class TypeBinding extends Binding {

	public int id= TypeIds.NoId;

	public long tagBits= 0; // See values in the interface TagBits below


	/** Base type definitions */
	public final static BaseTypeBinding INT= new BaseTypeBinding(
			TypeIds.T_int, TypeConstants.INT, new char[] { 'I' });

	public final static BaseTypeBinding BYTE= new BaseTypeBinding(
			TypeIds.T_byte, TypeConstants.BYTE, new char[] { 'B' });

	public final static BaseTypeBinding SHORT= new BaseTypeBinding(
			TypeIds.T_short, TypeConstants.SHORT, new char[] { 'S' });

	public final static BaseTypeBinding CHAR= new BaseTypeBinding(
			TypeIds.T_char, TypeConstants.CHAR, new char[] { 'C' });

	public final static BaseTypeBinding LONG= new BaseTypeBinding(
			TypeIds.T_long, TypeConstants.LONG, new char[] { 'J' });

	public final static BaseTypeBinding FLOAT= new BaseTypeBinding(
			TypeIds.T_float, TypeConstants.FLOAT, new char[] { 'F' });

	public final static BaseTypeBinding DOUBLE= new BaseTypeBinding(
			TypeIds.T_double, TypeConstants.DOUBLE, new char[] { 'D' });

	public final static BaseTypeBinding BOOLEAN= new BaseTypeBinding(
			TypeIds.T_boolean, TypeConstants.BOOLEAN, new char[] { 'Z' });

	public final static BaseTypeBinding NULL= new BaseTypeBinding(
			TypeIds.T_null, TypeConstants.NULL, new char[] { 'N' }); //N stands for null even if it is never internally used

	public final static BaseTypeBinding VOID= new BaseTypeBinding(
			TypeIds.T_void, TypeConstants.VOID, new char[] { 'V' });

	/**
	 * Match a well-known type id to its binding
	 */
	public static final TypeBinding wellKnownType(Scope scope, int id) {
		switch (id) {
			case TypeIds.T_boolean:
				return TypeBinding.BOOLEAN;
			case TypeIds.T_byte:
				return TypeBinding.BYTE;
			case TypeIds.T_char:
				return TypeBinding.CHAR;
			case TypeIds.T_short:
				return TypeBinding.SHORT;
			case TypeIds.T_double:
				return TypeBinding.DOUBLE;
			case TypeIds.T_float:
				return TypeBinding.FLOAT;
			case TypeIds.T_int:
				return TypeBinding.INT;
			case TypeIds.T_long:
				return TypeBinding.LONG;
			case TypeIds.T_JavaLangObject:
				return scope.getJavaLangObject();
			case TypeIds.T_JavaLangString:
				return scope.getJavaLangString();
			default:
				return null;
		}
	}

/* Answer true if the receiver can be instantiated
 */
	public boolean canBeInstantiated() {
		return !isBaseType();
	}

	/**
	 * Perform capture conversion on a given type (only effective on parameterized type with
	 * wildcards)
	 */
	public TypeBinding capture(Scope scope, int position) {
		return this;
	}

	/**
	 * In case of problems, returns the closest match found. It may not be perfect match, but the
	 * result of a best effort to improve fault-tolerance.
	 */
	public TypeBinding closestMatch() {
		return this; // by default no better type
	}

	/**
	 * Iterate through the type components to collect instances of leaf missing types
	 * 
	 * @param missingTypes
	 * @return missing types
	 */
	public List collectMissingTypes(List missingTypes) {
		return missingTypes;
	}

	/**
	 * Collect the substitutes into a map for certain type variables inside the receiver type e.g.
	 * Collection<T>.findSubstitute(T, Collection<List<X>>): T --> List<X> Constraints: A << F
	 * corresponds to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EXTENDS (1)) A = F corresponds
	 * to: F.collectSubstitutes(..., A, ..., CONSTRAINT_EQUAL (0)) A >> F corresponds to:
	 * F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER (2))
	 */
	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
		// no substitute by default
	}

	/**
	 * Answer the receiver's constant pool name. NOTE: This method should only be used during/after
	 * code gen. e.g. 'java/lang/Object'
	 */
	public abstract char[] constantPoolName();

	public String debugName() {
		return new String(readableName());
	}

/*
 * Answer the receiver's dimensions - 0 for non-array types
 */
	public int dimensions() {
		return 0;
	}

/* Answer the receiver's enclosing type... null if the receiver is a top level type.
 */
	public ReferenceBinding enclosingType() {
		return null;
	}

	public TypeBinding erasure() {
		return this;
	}

	/**
	 * Find supertype which originates from a given well-known type, or null if not found (using id
	 * avoids triggering the load of well-known type: 73740) NOTE: only works for erasures of
	 * well-known types, as random other types may share same id though being distincts.
	 * 
	 * @see TypeIds
	 */
	public ReferenceBinding findSuperTypeOriginatingFrom(int wellKnownOriginalID, boolean originalIsClass) {

		if (!(this instanceof ReferenceBinding))
			return null;
		ReferenceBinding reference= (ReferenceBinding)this;

		// do not allow type variables to match with erasures for free
		if (reference.id == wellKnownOriginalID || (original().id == wellKnownOriginalID))
			return reference;

		ReferenceBinding currentType= reference;
		// iterate superclass to avoid recording interfaces if searched supertype is class
		if (originalIsClass) {
			while ((currentType= currentType.superclass()) != null) {
				if (currentType.id == wellKnownOriginalID)
					return currentType;
				if (currentType.original().id == wellKnownOriginalID)
					return currentType;
			}
			return null;
		}
		ReferenceBinding[] interfacesToVisit= null;
		int nextPosition= 0;
		do {
			ReferenceBinding[] itsInterfaces= currentType.superInterfaces();
			if (itsInterfaces != null && itsInterfaces != Binding.NO_SUPERINTERFACES) {
				if (interfacesToVisit == null) {
					interfacesToVisit= itsInterfaces;
					nextPosition= interfacesToVisit.length;
				} else {
					int itsLength= itsInterfaces.length;
					if (nextPosition + itsLength >= interfacesToVisit.length)
						System.arraycopy(interfacesToVisit, 0, interfacesToVisit= new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
					nextInterface: for (int a= 0; a < itsLength; a++) {
						ReferenceBinding next= itsInterfaces[a];
						for (int b= 0; b < nextPosition; b++)
							if (next == interfacesToVisit[b])
								continue nextInterface;
						interfacesToVisit[nextPosition++]= next;
					}
				}
			}
		} while ((currentType= currentType.superclass()) != null);

		for (int i= 0; i < nextPosition; i++) {
			currentType= interfacesToVisit[i];
			if (currentType.id == wellKnownOriginalID)
				return currentType;
			if (currentType.original().id == wellKnownOriginalID)
				return currentType;
			ReferenceBinding[] itsInterfaces= currentType.superInterfaces();
			if (itsInterfaces != null && itsInterfaces != Binding.NO_SUPERINTERFACES) {
				int itsLength= itsInterfaces.length;
				if (nextPosition + itsLength >= interfacesToVisit.length)
					System.arraycopy(interfacesToVisit, 0, interfacesToVisit= new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
				nextInterface: for (int a= 0; a < itsLength; a++) {
					ReferenceBinding next= itsInterfaces[a];
					for (int b= 0; b < nextPosition; b++)
						if (next == interfacesToVisit[b])
							continue nextInterface;
					interfacesToVisit[nextPosition++]= next;
				}
			}
		}
		return null;
	}

	/**
	 * Find supertype which originates from a given type, or null if not found
	 */
	public TypeBinding findSuperTypeOriginatingFrom(TypeBinding otherType) {
		if (this == otherType)
			return this;
		if (otherType == null)
			return null;
		switch (kind()) {
			case Binding.ARRAY_TYPE:
				ArrayBinding arrayType= (ArrayBinding)this;
				int otherDim= otherType.dimensions();
				if (arrayType.dimensions != otherDim) {
					switch (otherType.id) {
						case TypeIds.T_JavaLangObject:
						case TypeIds.T_JavaIoSerializable:
						case TypeIds.T_JavaLangCloneable:
							return otherType;
					}
					if (otherDim < arrayType.dimensions && otherType.leafComponentType().id == TypeIds.T_JavaLangObject) {
						return otherType; // X[][] has Object[] as an implicit supertype
					}
					return null;
				}
				if (!(arrayType.leafComponentType instanceof ReferenceBinding))
					return null;
				TypeBinding leafSuperType= arrayType.leafComponentType.findSuperTypeOriginatingFrom(otherType.leafComponentType());
				if (leafSuperType == null)
					return null;
				return arrayType.environment().createArrayType(leafSuperType, arrayType.dimensions);

			case Binding.TYPE_PARAMETER:
				if (isCapture()) {
					CaptureBinding capture= (CaptureBinding)this;
					TypeBinding captureBound= capture.firstBound;
					if (captureBound instanceof ArrayBinding) {
						TypeBinding match= captureBound.findSuperTypeOriginatingFrom(otherType);
						if (match != null)
							return match;
					}
				}
				//$FALL-THROUGH$
			case Binding.TYPE:
			case Binding.PARAMETERIZED_TYPE:
			case Binding.GENERIC_TYPE:
			case Binding.RAW_TYPE:
			case Binding.WILDCARD_TYPE:
			case Binding.INTERSECTION_TYPE:
				// do not allow type variables/intersection types to match with erasures for free
				otherType= otherType.original();
				if (this == otherType)
					return this;
				if (original() == otherType)
					return this;
				ReferenceBinding currentType= (ReferenceBinding)this;
				if (!otherType.isInterface()) {
					while ((currentType= currentType.superclass()) != null) {
						if (currentType == otherType)
							return currentType;
						if (currentType.original() == otherType)
							return currentType;
					}
					return null;
				}
				ReferenceBinding[] interfacesToVisit= null;
				int nextPosition= 0;
				do {
					ReferenceBinding[] itsInterfaces= currentType.superInterfaces();
					if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
						if (interfacesToVisit == null) {
							interfacesToVisit= itsInterfaces;
							nextPosition= interfacesToVisit.length;
						} else {
							int itsLength= itsInterfaces.length;
							if (nextPosition + itsLength >= interfacesToVisit.length)
								System.arraycopy(interfacesToVisit, 0, interfacesToVisit= new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
							nextInterface: for (int a= 0; a < itsLength; a++) {
								ReferenceBinding next= itsInterfaces[a];
								for (int b= 0; b < nextPosition; b++)
									if (next == interfacesToVisit[b])
										continue nextInterface;
								interfacesToVisit[nextPosition++]= next;
							}
						}
					}
				} while ((currentType= currentType.superclass()) != null);

				for (int i= 0; i < nextPosition; i++) {
					currentType= interfacesToVisit[i];
					if (currentType == otherType)
						return currentType;
					if (currentType.original() == otherType)
						return currentType;
					ReferenceBinding[] itsInterfaces= currentType.superInterfaces();
					if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
						int itsLength= itsInterfaces.length;
						if (nextPosition + itsLength >= interfacesToVisit.length)
							System.arraycopy(interfacesToVisit, 0, interfacesToVisit= new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
						nextInterface: for (int a= 0; a < itsLength; a++) {
							ReferenceBinding next= itsInterfaces[a];
							for (int b= 0; b < nextPosition; b++)
								if (next == interfacesToVisit[b])
									continue nextInterface;
							interfacesToVisit[nextPosition++]= next;
						}
					}
				}
		}
		return null;
	}

	/**
	 * Returns the type to use for generic cast, or null if none required
	 */
	public TypeBinding genericCast(TypeBinding targetType) {
		if (this == targetType)
			return null;
		TypeBinding targetErasure= targetType.erasure();
		// type var get replaced by upper bound
		if (erasure().findSuperTypeOriginatingFrom(targetErasure) != null)
			return null;
		return targetErasure;
	}

	/**
	 * Answer the receiver classfile signature. Arrays & base types do not distinguish between
	 * signature() & constantPoolName(). NOTE: This method should only be used during/after code
	 * gen.
	 */
	public char[] genericTypeSignature() {
		return signature();
	}

	/**
	 * Return the supertype which would erase as a subtype of a given declaring class. If the
	 * receiver is already erasure compatible, then it will returned. If not, then will return the
	 * alternate lowest upper bound compatible with declaring class. NOTE: the declaringClass is
	 * already know to be compatible with the receiver
	 * 
	 * @param declaringClass to look for
	 * @return the lowest erasure compatible type (considering alternate bounds)
	 */
	public TypeBinding getErasureCompatibleType(TypeBinding declaringClass) {
		switch (kind()) {
			case Binding.TYPE_PARAMETER:
				TypeVariableBinding variable= (TypeVariableBinding)this;
				if (variable.erasure().findSuperTypeOriginatingFrom(declaringClass) != null) {
					return this; // no need for alternate receiver type
				}
				if (variable.superclass != null && variable.superclass.findSuperTypeOriginatingFrom(declaringClass) != null) {
					return variable.superclass.getErasureCompatibleType(declaringClass);
				}
				for (int i= 0, otherLength= variable.superInterfaces.length; i < otherLength; i++) {
					ReferenceBinding superInterface= variable.superInterfaces[i];
					if (superInterface.findSuperTypeOriginatingFrom(declaringClass) != null) {
						return superInterface.getErasureCompatibleType(declaringClass);
					}
				}
				return this; // only occur if passed null declaringClass for arraylength
			case Binding.INTERSECTION_TYPE:
				WildcardBinding intersection= (WildcardBinding)this;
				if (intersection.erasure().findSuperTypeOriginatingFrom(declaringClass) != null) {
					return this; // no need for alternate receiver type
				}
				if (intersection.superclass != null && intersection.superclass.findSuperTypeOriginatingFrom(declaringClass) != null) {
					return intersection.superclass.getErasureCompatibleType(declaringClass);
				}
				for (int i= 0, otherLength= intersection.superInterfaces.length; i < otherLength; i++) {
					ReferenceBinding superInterface= intersection.superInterfaces[i];
					if (superInterface.findSuperTypeOriginatingFrom(declaringClass) != null) {
						return superInterface.getErasureCompatibleType(declaringClass);
					}
				}
				return this; // only occur if passed null declaringClass for arraylength
			default:
				return this;
		}
	}

	public abstract PackageBinding getPackage();

	void initializeForStaticImports() {
		// only applicable to source types
	}

	public boolean isAnnotationType() {
		return false;
	}

	public final boolean isAnonymousType() {
		return (this.tagBits & TagBits.IsAnonymousType) != 0;
	}

/* Answer true if the receiver is an array
 */
	public final boolean isArrayType() {
		return (this.tagBits & TagBits.IsArrayType) != 0;
	}

/* Answer true if the receiver is a base type
 */
	public final boolean isBaseType() {
		return (this.tagBits & TagBits.IsBaseType) != 0;
	}

	/**
	 * Returns true if parameterized type AND not of the form List<?>
	 */
	public boolean isBoundParameterizedType() {
		return (this.tagBits & TagBits.IsBoundParameterizedType) != 0;
	}

	/**
	 * Returns true if the type is the capture of some wildcard
	 */
	public boolean isCapture() {
		return false;
	}

	public boolean isClass() {
		return false;
	}

/* Answer true if the receiver type can be assigned to the argument type (right)
 */
	public abstract boolean isCompatibleWith(TypeBinding right);

	public boolean isEnum() {
		return false;
	}

	/**
	 * Returns true if a type is identical to another one, or for generic types, true if compared to
	 * its raw type.
	 */
	public boolean isEquivalentTo(TypeBinding otherType) {
		if (this == otherType)
			return true;
		if (otherType == null)
			return false;
		switch (otherType.kind()) {
			case Binding.WILDCARD_TYPE:
			case Binding.INTERSECTION_TYPE:
				return ((WildcardBinding)otherType).boundCheck(this);
		}
		return false;
	}

	public boolean isGenericType() {
		return false;
	}

/* Answer true if the receiver's hierarchy has problems (always false for arrays & base types)
 */
	public final boolean isHierarchyInconsistent() {
		return (this.tagBits & TagBits.HierarchyHasProblems) != 0;
	}

	public boolean isInterface() {
		return false;
	}

	/**
	 * Returns true if the current type denotes an intersection type: Number & Comparable<?>
	 */
	public boolean isIntersectionType() {
		return false;
	}

	public final boolean isLocalType() {
		return (this.tagBits & TagBits.IsLocalType) != 0;
	}

	public final boolean isMemberType() {
		return (this.tagBits & TagBits.IsMemberType) != 0;
	}

	public final boolean isNestedType() {
		return (this.tagBits & TagBits.IsNestedType) != 0;
	}

	public final boolean isNumericType() {
		switch (this.id) {
			case TypeIds.T_int:
			case TypeIds.T_float:
			case TypeIds.T_double:
			case TypeIds.T_short:
			case TypeIds.T_byte:
			case TypeIds.T_long:
			case TypeIds.T_char:
				return true;
			default:
				return false;
		}
	}

	/**
	 * Returns true if the type is parameterized, e.g. List<String>. Note that some instances of
	 * ParameterizedTypeBinding have no arguments, like for non-generic members of a parameterized
	 * type. Use {@link #isParameterizedTypeWithActualArguments()} instead to find out.
	 */
	public final boolean isParameterizedType() {
		return kind() == Binding.PARAMETERIZED_TYPE;
	}

	/**
	 * Returns true if the type is parameterized, e.g. List<String> Note that some instances of
	 * ParameterizedTypeBinding do answer false to {@link #isParameterizedType()} in case they have
	 * no arguments, like for non-generic members of a parameterized type. i.e.
	 * {@link #isParameterizedType()} is not equivalent to testing
	 * <code>type.kind() == Binding.PARAMETERIZED_TYPE</code>
	 */
	public final boolean isParameterizedTypeWithActualArguments() {
		return (kind() == Binding.PARAMETERIZED_TYPE)
					&& ((ParameterizedTypeBinding)this).arguments != null;
	}

	/**
	 * Returns true if the type is parameterized using its own type variables as arguments
	 */
	public boolean isParameterizedWithOwnVariables() {
		if (kind() != Binding.PARAMETERIZED_TYPE)
			return false;
		ParameterizedTypeBinding paramType= (ParameterizedTypeBinding)this;
		if (paramType.arguments == null)
			return false;
		TypeVariableBinding[] variables= erasure().typeVariables();
		for (int i= 0, length= variables.length; i < length; i++) {
			if (variables[i] != paramType.arguments[i])
				return false;
		}
		ReferenceBinding enclosing= paramType.enclosingType();
		if (enclosing != null && enclosing.erasure().isGenericType()
				&& !enclosing.isParameterizedWithOwnVariables()) {
			return false;
		}
		return true;
	}

	private boolean isProvableDistinctSubType(TypeBinding otherType) {
		if (otherType.isInterface()) {
			if (isInterface())
				return false;
			if (isArrayType()
					|| ((this instanceof ReferenceBinding) && ((ReferenceBinding)this).isFinal())
					|| (isTypeVariable() && ((TypeVariableBinding)this).superclass().isFinal())) {
				return !isCompatibleWith(otherType);
			}
			return false;
		} else {
			if (isInterface()) {
				if (otherType.isArrayType()
						|| ((otherType instanceof ReferenceBinding) && ((ReferenceBinding)otherType).isFinal())
						|| (otherType.isTypeVariable() && ((TypeVariableBinding)otherType).superclass().isFinal())) {
					return !isCompatibleWith(otherType);
				}
			} else {
				if (!isTypeVariable() && !otherType.isTypeVariable()) {
					return !isCompatibleWith(otherType);
				}
			}
		}
		return false;
	}

	/**
	 * Returns true if a type is provably distinct from another one,
	 */
	public boolean isProvablyDistinct(TypeBinding otherType) {
		if (this == otherType)
			return false;
		if (otherType == null)
			return true;

		switch (kind()) {

			case Binding.PARAMETERIZED_TYPE:
				ParameterizedTypeBinding paramType= (ParameterizedTypeBinding)this;
				switch (otherType.kind()) {
					case Binding.PARAMETERIZED_TYPE:
						ParameterizedTypeBinding otherParamType= (ParameterizedTypeBinding)otherType;
						if (paramType.genericType() != otherParamType.genericType())
							return true;
						if (!paramType.isStatic()) { // static member types do not compare their enclosing
							ReferenceBinding enclosing= enclosingType();
							if (enclosing != null) {
								ReferenceBinding otherEnclosing= otherParamType.enclosingType();
								if (otherEnclosing == null)
									return true;
								if ((otherEnclosing.tagBits & TagBits.HasDirectWildcard) == 0) {
									if (enclosing.isProvablyDistinct(otherEnclosing))
										return true; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=302919
								} else {
									if (!enclosing.isEquivalentTo(otherParamType.enclosingType()))
										return true;
								}
							}
						}
						int length= paramType.arguments == null ? 0 : paramType.arguments.length;
						TypeBinding[] otherArguments= otherParamType.arguments;
						int otherLength= otherArguments == null ? 0 : otherArguments.length;
						if (otherLength != length)
							return true;
						for (int i= 0; i < length; i++) {
							if (paramType.arguments[i].isProvablyDistinctTypeArgument(otherArguments[i], paramType, i))
								return true;
						}
						return false;

					case Binding.GENERIC_TYPE:
						SourceTypeBinding otherGenericType= (SourceTypeBinding)otherType;
						if (paramType.genericType() != otherGenericType)
							return true;
						if (!paramType.isStatic()) { // static member types do not compare their enclosing
							ReferenceBinding enclosing= enclosingType();
							if (enclosing != null) {
								ReferenceBinding otherEnclosing= otherGenericType.enclosingType();
								if (otherEnclosing == null)
									return true;
								if ((otherEnclosing.tagBits & TagBits.HasDirectWildcard) == 0) {
									if (enclosing != otherEnclosing)
										return true;
								} else {
									if (!enclosing.isEquivalentTo(otherGenericType.enclosingType()))
										return true;
								}
							}
						}
						length= paramType.arguments == null ? 0 : paramType.arguments.length;
						otherArguments= otherGenericType.typeVariables();
						otherLength= otherArguments == null ? 0 : otherArguments.length;
						if (otherLength != length)
							return true;
						for (int i= 0; i < length; i++) {
							if (paramType.arguments[i].isProvablyDistinctTypeArgument(otherArguments[i], paramType, i))
								return true;
						}
						return false;

					case Binding.RAW_TYPE:
						return erasure() != otherType.erasure();
				}
				return true;

			case Binding.RAW_TYPE:

				switch (otherType.kind()) {

					case Binding.GENERIC_TYPE:
					case Binding.PARAMETERIZED_TYPE:
					case Binding.RAW_TYPE:
						return erasure() != otherType.erasure();
				}
				return true;

			default:
				break;
		}
		return true;
	}

	/**
	 * Returns false if two given types could not intersect as argument types: List<Throwable> &
	 * List<Runnable> --> false List<? extends Throwable> & List<? extends Runnable> --> true List<?
	 * extends String> & List<? extends Runnable> --> false
	 */
	private boolean isProvablyDistinctTypeArgument(TypeBinding otherArgument, final ParameterizedTypeBinding paramType, final int rank) {
		if (this == otherArgument)
			return false;

		TypeBinding upperBound1= null;
		TypeBinding lowerBound1= null;
		switch (kind()) {
			case Binding.WILDCARD_TYPE:
				WildcardBinding wildcard= (WildcardBinding)this;
				switch (wildcard.boundKind) {
					case Wildcard.EXTENDS:
						upperBound1= wildcard.bound;
						break;
					case Wildcard.SUPER:
						lowerBound1= wildcard.bound;
						break;
					case Wildcard.UNBOUND:
						return false;
				}
				break;
			case Binding.INTERSECTION_TYPE:
				break;
			case Binding.TYPE_PARAMETER:
				final TypeVariableBinding variable= (TypeVariableBinding)this;
				if (variable.isCapture()) {
					CaptureBinding capture= (CaptureBinding)variable;
					switch (capture.wildcard.boundKind) {
						case Wildcard.EXTENDS:
							upperBound1= capture.wildcard.bound;
							break;
						case Wildcard.SUPER:
							lowerBound1= capture.wildcard.bound;
							break;
						case Wildcard.UNBOUND:
							return false;
					}
					break;
				}
				if (variable.firstBound == null) // unbound variable
					return false;
				TypeBinding eliminatedType= Scope.convertEliminatingTypeVariables(variable, paramType.genericType(), rank, null);
				switch (eliminatedType.kind()) {
					case Binding.WILDCARD_TYPE:
					case Binding.INTERSECTION_TYPE:
						wildcard= (WildcardBinding)eliminatedType;
						switch (wildcard.boundKind) {
							case Wildcard.EXTENDS:
								upperBound1= wildcard.bound;
								break;
							case Wildcard.SUPER:
								lowerBound1= wildcard.bound;
								break;
							case Wildcard.UNBOUND:
								return false;
						}
						break;
				}
				break;
		}
		TypeBinding upperBound2= null;
		TypeBinding lowerBound2= null;
		switch (otherArgument.kind()) {
			case Binding.WILDCARD_TYPE:
				WildcardBinding otherWildcard= (WildcardBinding)otherArgument;
				switch (otherWildcard.boundKind) {
					case Wildcard.EXTENDS:
						upperBound2= otherWildcard.bound;
						break;
					case Wildcard.SUPER:
						lowerBound2= otherWildcard.bound;
						break;
					case Wildcard.UNBOUND:
						return false;
				}
				break;
			case Binding.INTERSECTION_TYPE:
				break;
			case Binding.TYPE_PARAMETER:
				TypeVariableBinding otherVariable= (TypeVariableBinding)otherArgument;
				if (otherVariable.isCapture()) {
					CaptureBinding otherCapture= (CaptureBinding)otherVariable;
					switch (otherCapture.wildcard.boundKind) {
						case Wildcard.EXTENDS:
							upperBound2= otherCapture.wildcard.bound;
							break;
						case Wildcard.SUPER:
							lowerBound2= otherCapture.wildcard.bound;
							break;
						case Wildcard.UNBOUND:
							return false;
					}
					break;
				}
				if (otherVariable.firstBound == null) // unbound variable
					return false;
				TypeBinding otherEliminatedType= Scope.convertEliminatingTypeVariables(otherVariable, paramType.genericType(), rank, null);
				switch (otherEliminatedType.kind()) {
					case Binding.WILDCARD_TYPE:
					case Binding.INTERSECTION_TYPE:
						otherWildcard= (WildcardBinding)otherEliminatedType;
						switch (otherWildcard.boundKind) {
							case Wildcard.EXTENDS:
								upperBound2= otherWildcard.bound;
								break;
							case Wildcard.SUPER:
								lowerBound2= otherWildcard.bound;
								break;
							case Wildcard.UNBOUND:
								return false;
						}
						break;
				}
				break;
		}
		if (lowerBound1 != null) {
			if (lowerBound2 != null) {
				return false; // Object could always be a candidate

			} else if (upperBound2 != null) {
				if (lowerBound1.isTypeVariable() || upperBound2.isTypeVariable()) {
					return false;
				}
				return !lowerBound1.isCompatibleWith(upperBound2);
			} else {
				if (lowerBound1.isTypeVariable() || otherArgument.isTypeVariable()) {
					return false;
				}
				return !lowerBound1.isCompatibleWith(otherArgument);
			}
		} else if (upperBound1 != null) {
			if (lowerBound2 != null) {
				return !lowerBound2.isCompatibleWith(upperBound1);
			} else if (upperBound2 != null) {
				return upperBound1.isProvableDistinctSubType(upperBound2)
							&& upperBound2.isProvableDistinctSubType(upperBound1);
			} else {
				return otherArgument.isProvableDistinctSubType(upperBound1);
			}
		} else {
			if (lowerBound2 != null) {
				if (lowerBound2.isTypeVariable() || isTypeVariable()) {
					return false;
				}
				return !lowerBound2.isCompatibleWith(this);
			} else if (upperBound2 != null) {
				return isProvableDistinctSubType(upperBound2);
			} else {
				return true; // ground types should have been the same
			}
		}
	}

	public final boolean isRawType() {
		return kind() == Binding.RAW_TYPE;
	}

	/**
	 * JLS(3) 4.7. Note: Foo<?>.Bar is also reifiable
	 */
	public boolean isReifiable() {
		TypeBinding leafType= leafComponentType();
		if (!(leafType instanceof ReferenceBinding))
			return true;
		ReferenceBinding current= (ReferenceBinding)leafType;
		do {
			switch (current.kind()) {
				case Binding.TYPE_PARAMETER:
				case Binding.WILDCARD_TYPE:
				case Binding.INTERSECTION_TYPE:
				case Binding.GENERIC_TYPE:
					return false;
				case Binding.PARAMETERIZED_TYPE:
					if (current.isBoundParameterizedType())
						return false;
					break;
				case Binding.RAW_TYPE:
					return true;
			}
			if (current.isStatic()) {
				return true;
			}
			if (current.isLocalType()) {
				LocalTypeBinding localTypeBinding= (LocalTypeBinding)current.erasure();
				MethodBinding enclosingMethod= localTypeBinding.enclosingMethod;
				if (enclosingMethod != null && enclosingMethod.isStatic()) {
					return true;
				}
			}
		} while ((current= current.enclosingType()) != null);
		return true;
	}

	/**
	 * Returns true if a given type may be thrown
	 */
	public boolean isThrowable() {
		return false;
	}

// JLS3: 4.5.1.1
	public boolean isTypeArgumentContainedBy(TypeBinding otherType) {
		if (this == otherType)
			return true;
		switch (otherType.kind()) {
			// allow wildcard containment
			case Binding.WILDCARD_TYPE:
			case Binding.INTERSECTION_TYPE:

				TypeBinding lowerBound= this;
				TypeBinding upperBound= this;
				switch (kind()) {
					case Binding.WILDCARD_TYPE:
					case Binding.INTERSECTION_TYPE:
						WildcardBinding wildcard= (WildcardBinding)this;
						switch (wildcard.boundKind) {
							case Wildcard.EXTENDS:
								if (wildcard.otherBounds != null) // intersection type
									break;
								upperBound= wildcard.bound;
								lowerBound= null;
								break;
							case Wildcard.SUPER:
								upperBound= wildcard;
								lowerBound= wildcard.bound;
								break;
							case Wildcard.UNBOUND:
								upperBound= wildcard;
								lowerBound= null;
						}
						break;
					case Binding.TYPE_PARAMETER:
						if (isCapture()) {
							CaptureBinding capture= (CaptureBinding)this;
							if (capture.lowerBound != null)
								lowerBound= capture.lowerBound;
						}
				}
				WildcardBinding otherWildcard= (WildcardBinding)otherType;
				if (otherWildcard.otherBounds != null)
					return false; // not a true wildcard (intersection type)
				TypeBinding otherBound= otherWildcard.bound;
				switch (otherWildcard.boundKind) {
					case Wildcard.EXTENDS:
						if (otherBound == this)
							return true; // ? extends T  <=  ? extends ? extends T
						if (upperBound == null)
							return false;
						TypeBinding match= upperBound.findSuperTypeOriginatingFrom(otherBound);
						if (match != null && (match= match.leafComponentType()).isRawType()) {
							return match == otherBound.leafComponentType(); // forbide: Collection <=  ? extends Collection<?>
																			// forbide: Collection[] <=  ? extends Collection<?>[]
						}
						return upperBound.isCompatibleWith(otherBound);

					case Wildcard.SUPER:
						if (otherBound == this)
							return true; // ? super T  <=  ? super ? super T
						if (lowerBound == null)
							return false;
						match= otherBound.findSuperTypeOriginatingFrom(lowerBound);
						if (match != null && (match= match.leafComponentType()).isRawType()) {
							return match == lowerBound.leafComponentType(); // forbide: Collection <=  ? super Collection<?>
																			// forbide: Collection[] <=  ? super Collection<?>[]
						}
						return otherBound.isCompatibleWith(lowerBound);

					case Wildcard.UNBOUND:
					default:
						return true;
				}
				// allow List<?> to match List<? extends Object> (and reciprocally)
			case Binding.PARAMETERIZED_TYPE:
				if (!isParameterizedType())
					return false;
				ParameterizedTypeBinding paramType= (ParameterizedTypeBinding)this;
				ParameterizedTypeBinding otherParamType= (ParameterizedTypeBinding)otherType;
				if (paramType.actualType() != otherParamType.actualType())
					return false;
				if (!paramType.isStatic()) { // static member types do not compare their enclosing
					ReferenceBinding enclosing= enclosingType();
					if (enclosing != null) {
						ReferenceBinding otherEnclosing= otherParamType.enclosingType();
						if (otherEnclosing == null)
							return false;
						if ((otherEnclosing.tagBits & TagBits.HasDirectWildcard) == 0) {
							if (enclosing != otherEnclosing)
								return false;
						} else {
							if (!enclosing.isEquivalentTo(otherParamType.enclosingType()))
								return false;
						}
					}
				}
				int length= paramType.arguments == null ? 0 : paramType.arguments.length;
				TypeBinding[] otherArguments= otherParamType.arguments;
				int otherLength= otherArguments == null ? 0 : otherArguments.length;
				if (otherLength != length)
					return false;
				nextArgument: for (int i= 0; i < length; i++) {
					TypeBinding argument= paramType.arguments[i];
					TypeBinding otherArgument= otherArguments[i];
					if (argument == otherArgument)
						continue nextArgument;
					int kind= argument.kind();
					if (otherArgument.kind() != kind)
						return false;
					switch (kind) {
						case Binding.PARAMETERIZED_TYPE:
							if (argument.isTypeArgumentContainedBy(otherArgument)) // recurse
								continue nextArgument;
							break;
						case Binding.WILDCARD_TYPE:
						case Binding.INTERSECTION_TYPE:
							WildcardBinding wildcard= (WildcardBinding)argument;
							otherWildcard= (WildcardBinding)otherArgument;
							switch (wildcard.boundKind) {
								case Wildcard.EXTENDS:
									// match "? extends <upperBound>" with "?"
									if (otherWildcard.boundKind == Wildcard.UNBOUND
											&& wildcard.bound == wildcard.typeVariable().upperBound())
										continue nextArgument;
									break;
								case Wildcard.SUPER:
									break;
								case Wildcard.UNBOUND:
									// match "?" with "? extends <upperBound>"
									if (otherWildcard.boundKind == Wildcard.EXTENDS
											&& otherWildcard.bound == otherWildcard.typeVariable().upperBound())
										continue nextArgument;
									break;
							}
							break;
					}
					return false;
				}
				return true;
		}
		// (? super Object) <= Object
		if (otherType.id == TypeIds.T_JavaLangObject) {
			switch (kind()) {
				case Binding.WILDCARD_TYPE:
					WildcardBinding wildcard= (WildcardBinding)this;
					if (wildcard.boundKind == Wildcard.SUPER && wildcard.bound.id == TypeIds.T_JavaLangObject) {
						return true;
					}
					break;
			}
		}
		return false;
	}

	/**
	 * Returns true if the type was declared as a type variable
	 */
	public boolean isTypeVariable() {
		return false;
	}

	/**
	 * Returns true if wildcard type of the form '?' (no bound)
	 */
	public boolean isUnboundWildcard() {
		return false;
	}

	/**
	 * Returns true if the type is a subclass of java.lang.Error or java.lang.RuntimeException
	 */
	public boolean isUncheckedException(boolean includeSupertype) {
		return false;
	}

	/**
	 * Returns true if the type is a wildcard
	 */
	public boolean isWildcard() {
		return false;
	}

/* API
 * Answer the receiver's binding type from Binding.BindingID.
 */
	public int kind() {
		return Binding.TYPE;
	}

	public TypeBinding leafComponentType() {
		return this;
	}

	/**
	 * Meant to be invoked on compatible types, to figure if unchecked conversion is necessary
	 */
	public boolean needsUncheckedConversion(TypeBinding targetType) {

		if (this == targetType)
			return false;
		targetType= targetType.leafComponentType();
		if (!(targetType instanceof ReferenceBinding))
			return false;

		TypeBinding currentType= leafComponentType();
		TypeBinding match= currentType.findSuperTypeOriginatingFrom(targetType);
		if (!(match instanceof ReferenceBinding))
			return false;
		ReferenceBinding compatible= (ReferenceBinding)match;
		while (compatible.isRawType()) {
			if (targetType.isBoundParameterizedType())
				return true;
			if (compatible.isStatic())
				break;
			if ((compatible= compatible.enclosingType()) == null)
				break;
			if ((targetType= targetType.enclosingType()) == null)
				break;
		}
		return false;
	}

	/**
	 * Returns the orignal generic type instantiated by the receiver type, or itself if not. This is
	 * similar to erasure process, except it doesn't erase type variable, wildcard, intersection
	 * types etc...
	 */
	public TypeBinding original() {
		switch (kind()) {
			case Binding.PARAMETERIZED_TYPE:
			case Binding.RAW_TYPE:
			case Binding.ARRAY_TYPE:
				return erasure();
			default:
				return this;
		}
	}

	/**
	 * Answer the qualified name of the receiver's package separated by periods or an empty string
	 * if its the default package.
	 * 
	 * For example, {java.util}.
	 */

	public char[] qualifiedPackageName() {
		PackageBinding packageBinding= getPackage();
		return packageBinding == null
				|| packageBinding.compoundName == CharOperation.NO_CHAR_CHAR ? CharOperation.NO_CHAR
				: packageBinding.readableName();
	}

	/**
	 * Answer the source name for the type. In the case of member types, as the qualified name from
	 * its top level type. For example, for a member type N defined inside M & A: "A.M.N".
	 */

	public abstract char[] qualifiedSourceName();

	/**
	 * Answer the receiver classfile signature. Arrays & base types do not distinguish between
	 * signature() & constantPoolName(). NOTE: This method should only be used during/after code
	 * gen.
	 */
	public char[] signature() {
		return constantPoolName();
	}

	public abstract char[] sourceName();

	public void swapUnresolved(UnresolvedReferenceBinding unresolvedType,
			ReferenceBinding resolvedType, LookupEnvironment environment) {
		// subclasses must override if they wrap another type binding
	}

	public TypeVariableBinding[] typeVariables() {
		return Binding.NO_TYPE_VARIABLES;
	}
}