All Downloads are FREE. Search and download functionalities are using the official Maven repository.

Explore the source code of the class ReferenceType.java

package org.aspectj.apache.bcel.generic;

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache BCEL" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact [email protected]
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache BCEL", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * .
 */

import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.Repository;
import org.aspectj.apache.bcel.classfile.JavaClass;

/**
 * Super class for object and array types.
 * 
 * @version $Id: ReferenceType.java,v 1.6 2009/09/09 22:18:20 aclement Exp $
 * @author M. Dahm
 */
public abstract class ReferenceType extends Type {

	protected ReferenceType(byte t, String s) {
		super(t, s);
	}

	ReferenceType() {
		super(Constants.T_OBJECT, "");
	}

	/**
	 * Return true iff this type is castable to another type t as defined in the JVM specification. The case where this is Type.NULL
	 * is not defined (see the CHECKCAST definition in the JVM specification). However, because e.g. CHECKCAST doesn't throw a
	 * ClassCastException when casting a null reference to any Object, true is returned in this case.
	 */
	public boolean isCastableTo(Type t) {
		if (this.equals(Type.NULL)) {
			return true; // If this is ever changed in isAssignmentCompatible()
		}

		return isAssignmentCompatibleWith(t);
		/*
		 * Yes, it's true: It's the same definition. See vmspec2 AASTORE / CHECKCAST definitions.
		 */
	}

	/**
	 * Return true iff this is assignment compatible with another type t as defined in the JVM specification; see the AASTORE
	 * definition there.
	 */
	public boolean isAssignmentCompatibleWith(Type t) {
		if (!(t instanceof ReferenceType)) {
			return false;
		}

		ReferenceType T = (ReferenceType) t;

		if (this.equals(Type.NULL)) {
			return true; // This is not explicitely stated, but clear. Isn't it?
		}

		/*
		 * If this is a class type then
		 */
		if (this instanceof ObjectType && ((ObjectType) this).referencesClass()) {
			/*
			 * If T is a class type, then this must be the same class as T, or this must be a subclass of T;
			 */
			if (T instanceof ObjectType && ((ObjectType) T).referencesClass()) {
				if (this.equals(T)) {
					return true;
				}

				if (Repository.instanceOf(((ObjectType) this).getClassName(), ((ObjectType) T).getClassName())) {
					return true;
				}
			}

			/*
			 * If T is an interface type, this must implement interface T.
			 */
			if (T instanceof ObjectType && ((ObjectType) T).referencesInterface()) {
				if (Repository.implementationOf(((ObjectType) this).getClassName(), ((ObjectType) T).getClassName())) {
					return true;
				}
			}
		}

		/*
		 * If this is an interface type, then:
		 */
		if (this instanceof ObjectType && ((ObjectType) this).referencesInterface()) {
			/*
			 * If T is a class type, then T must be Object (2.4.7).
			 */
			if (T instanceof ObjectType && ((ObjectType) T).referencesClass()) {
				if (T.equals(Type.OBJECT)) {
					return true;
				}
			}

			/*
			 * If T is an interface type, then T must be the same interface as this or a superinterface of this (2.13.2).
			 */
			if (T instanceof ObjectType && ((ObjectType) T).referencesInterface()) {
				if (this.equals(T)) {
					return true;
				}
				if (Repository.implementationOf(((ObjectType) this).getClassName(), ((ObjectType) T).getClassName())) {
					return true;
				}
			}
		}

		/*
		 * If this is an array type, namely, the type SC[], that is, an array of components of type SC, then:
		 */
		if (this instanceof ArrayType) {
			/*
			 * If T is a class type, then T must be Object (2.4.7).
			 */
			if (T instanceof ObjectType && ((ObjectType) T).referencesClass()) {
				if (T.equals(Type.OBJECT)) {
					return true;
				}
			}

			/*
			 * If T is an array type TC[], that is, an array of components of type TC, then one of the following must be true:
			 */
			if (T instanceof ArrayType) {
				/*
				 * TC and SC are the same primitive type (2.4.1).
				 */
				Type sc = ((ArrayType) this).getElementType();
				Type tc = ((ArrayType) this).getElementType();

				if (sc instanceof BasicType && tc instanceof BasicType && sc.equals(tc)) {
					return true;
				}

				/*
				 * TC and SC are reference types (2.4.6), and type SC is assignable to TC by these runtime rules.
				 */
				if (tc instanceof ReferenceType && sc instanceof ReferenceType
						&& ((ReferenceType) sc).isAssignmentCompatibleWith(tc)) {
					return true;
				}
			}

			/* If T is an interface type, T must be one of the interfaces implemented by arrays (2.15). */
			// TODO: Check if this is still valid or find a way to dynamically find out which
			// interfaces arrays implement. However, as of the JVM specification edition 2, there
			// are at least two different pages where assignment compatibility is defined and
			// on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable' or
			// 'java.io.Serializable'"
			if (T instanceof ObjectType && ((ObjectType) T).referencesInterface()) {
				for (int ii = 0; ii < Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS.length; ii++) {
					if (T.equals(new ObjectType(Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS[ii]))) {
						return true;
					}
				}
			}
		}
		return false; // default.
	}

	/**
	 * This commutative operation returns the first common superclass (narrowest ReferenceType referencing a class, not an
	 * interface). If one of the types is a superclass of the other, the former is returned. If "this" is Type.NULL, then t is
	 * returned. If t is Type.NULL, then "this" is returned. If "this" equals t ['this.equals(t)'] "this" is returned. If "this" or
	 * t is an ArrayType, then Type.OBJECT is returned; unless their dimensions match. Then an ArrayType of the same number of
	 * dimensions is returned, with its basic type being the first common super class of the basic types of "this" and t. If "this"
	 * or t is a ReferenceType referencing an interface, then Type.OBJECT is returned. If not all of the two classes' superclasses
	 * cannot be found, "null" is returned. See the JVM specification edition 2, "4.9.2 The Bytecode Verifier".
	 */
	public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
		if (this.equals(Type.NULL)) {
			return t;
		}
		if (t.equals(Type.NULL)) {
			return this;
		}
		if (this.equals(t)) {
			return this;
			/*
			 * TODO: Above sounds a little arbitrary. On the other hand, there is no object referenced by Type.NULL so we can also
			 * say all the objects referenced by Type.NULL were derived from java.lang.Object. However, the Java Language's
			 * "instanceof" operator proves us wrong: "null" is not referring to an instance of java.lang.Object :)
			 */
		}

		/* This code is from a bug report by Konstantin Shagin  */

		if (this instanceof ArrayType && t instanceof ArrayType) {
			ArrayType arrType1 = (ArrayType) this;
			ArrayType arrType2 = (ArrayType) t;
			if (arrType1.getDimensions() == arrType2.getDimensions() && arrType1.getBasicType() instanceof ObjectType
					&& arrType2.getBasicType() instanceof ObjectType) {
				return new ArrayType(((ObjectType) arrType1.getBasicType()).getFirstCommonSuperclass((ObjectType) arrType2
						.getBasicType()), arrType1.getDimensions());

			}
		}

		if (this instanceof ArrayType || t instanceof ArrayType) {
			return Type.OBJECT;
			// TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
		}

		if (this instanceof ObjectType && ((ObjectType) this).referencesInterface() || t instanceof ObjectType
				&& ((ObjectType) t).referencesInterface()) {
			return Type.OBJECT;
			// TODO: The above line is correct comparing to the vmspec2. But one could
			// make class file verification a bit stronger here by using the notion of
			// superinterfaces or even castability or assignment compatibility.
		}

		// this and t are ObjectTypes, see above.
		ObjectType thiz = (ObjectType) this;
		ObjectType other = (ObjectType) t;
		JavaClass[] thiz_sups = Repository.lookupClass(thiz.getClassName()).getSuperClasses();// getSuperClasses(thiz.getClassName());
		JavaClass[] other_sups = Repository.lookupClass(other.getClassName()).getSuperClasses();// getSuperClasses(other.getClassName());

		if (thiz_sups == null || other_sups == null) {
			return null;
		}

		// Waaahh...
		JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
		JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
		System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
		System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
		this_sups[0] = Repository.lookupClass(thiz.getClassName());
		t_sups[0] = Repository.lookupClass(other.getClassName());

		for (int i = 0; i < t_sups.length; i++) {
			for (int j = 0; j < this_sups.length; j++) {
				if (this_sups[j].equals(t_sups[i])) {
					return new ObjectType(this_sups[j].getClassName());
				}
			}
		}

		// Huh? Did you ask for Type.OBJECT's superclass??
		return null;
	}

	// /**
	// * This commutative operation returns the first common superclass (narrowest ReferenceType referencing a class, not an
	// * interface). If one of the types is a superclass of the other, the former is returned. If "this" is Type.NULL, then t is
	// * returned. If t is Type.NULL, then "this" is returned. If "this" equals t ['this.equals(t)'] "this" is returned. If "this"
	// or
	// * t is an ArrayType, then Type.OBJECT is returned. If "this" or t is a ReferenceType referencing an interface, then
	// Type.OBJECT
	// * is returned. If not all of the two classes' superclasses cannot be found, "null" is returned. See the JVM specification
	// * edition 2, "4.9.2 The Bytecode Verifier".
	// *
	// * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has slightly changed semantics.
	// */
	// public ReferenceType firstCommonSuperclass(ReferenceType t) {
	// if (this.equals(Type.NULL)) {
	// return t;
	// }
	// if (t.equals(Type.NULL)) {
	// return this;
	// }
	// if (this.equals(t)) {
	// return this;
	// /*
	// * TODO: Above sounds a little arbitrary. On the other hand, there is no object referenced by Type.NULL so we can also
	// * say all the objects referenced by Type.NULL were derived from java.lang.Object. However, the Java Language's
	// * "instanceof" operator proves us wrong: "null" is not referring to an instance of java.lang.Object :)
	// */
	// }
	//
	// if (this instanceof ArrayType || t instanceof ArrayType) {
	// return Type.OBJECT;
	// // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
	// }
	//
	// if (this instanceof ObjectType && ((ObjectType) this).referencesInterface() || t instanceof ObjectType
	// && ((ObjectType) t).referencesInterface()) {
	// return Type.OBJECT;
	// // TODO: The above line is correct comparing to the vmspec2. But one could
	// // make class file verification a bit stronger here by using the notion of
	// // superinterfaces or even castability or assignment compatibility.
	// }
	//
	// // this and t are ObjectTypes, see above.
	// ObjectType thiz = (ObjectType) this;
	// ObjectType other = (ObjectType) t;
	// JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
	// JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
	//
	// if (thiz_sups == null || other_sups == null) {
	// return null;
	// }
	//
	// // Waaahh...
	// JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
	// JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
	// System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
	// System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
	// this_sups[0] = Repository.lookupClass(thiz.getClassName());
	// t_sups[0] = Repository.lookupClass(other.getClassName());
	//
	// for (int i = 0; i < t_sups.length; i++) {
	// for (int j = 0; j < this_sups.length; j++) {
	// if (this_sups[j].equals(t_sups[i])) {
	// return new ObjectType(this_sups[j].getClassName());
	// }
	// }
	// }
	//
	// // Huh? Did you ask for Type.OBJECT's superclass??
	// return null;
	// }
}