/*******************************************************************************
* Copyright (c) 2000, 2006 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.aspectj.org.eclipse.jdt.internal.core;
import java.util.ArrayList;
import java.util.HashMap;
import org.aspectj.org.eclipse.jdt.core.*;
import org.aspectj.org.eclipse.jdt.core.IClassFile;
import org.aspectj.org.eclipse.jdt.core.IField;
import org.aspectj.org.eclipse.jdt.core.IJavaElement;
import org.aspectj.org.eclipse.jdt.core.IPackageFragment;
import org.aspectj.org.eclipse.jdt.core.IType;
import org.aspectj.org.eclipse.jdt.core.JavaModelException;
import org.aspectj.org.eclipse.jdt.core.Signature;
import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IBinaryField;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IBinaryNestedType;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IBinaryType;
import org.aspectj.org.eclipse.jdt.internal.compiler.util.SuffixConstants;
/**
* Element info for <code>ClassFile</code> handles.
*/
/* package */ class ClassFileInfo extends OpenableElementInfo implements SuffixConstants {
/**
* The children of the <code>BinaryType</code> corresponding to our
* <code>ClassFile</code>. These are kept here because we don't have
* access to the <code>BinaryType</code> info (<code>ClassFileReader</code>).
*/
protected JavaElement[] binaryChildren = null;
/*
* The type parameters in this class file.
*/
protected ITypeParameter[] typeParameters;
/**
* Creates the handles and infos for the fields of the given binary type.
* Adds new handles to the given vector.
*/
private void generateFieldInfos(IType type, IBinaryType typeInfo, HashMap newElements, ArrayList childrenHandles) {
// Make the fields
IBinaryField[] fields = typeInfo.getFields();
if (fields == null) {
return;
}
JavaModelManager manager = JavaModelManager.getJavaModelManager();
for (int i = 0, fieldCount = fields.length; i < fieldCount; i++) {
IBinaryField fieldInfo = fields[i];
IField field = new BinaryField((JavaElement)type, manager.intern(new String(fieldInfo.getName())));
newElements.put(field, fieldInfo);
childrenHandles.add(field);
}
}
/**
* Creates the handles for the inner types of the given binary type.
* Adds new handles to the given vector.
*/
private void generateInnerClassHandles(IType type, IBinaryType typeInfo, ArrayList childrenHandles) {
// Add inner types
// If the current type is an inner type, innerClasses returns
// an extra entry for the current type. This entry must be removed.
// Can also return an entry for the enclosing type of an inner type.
IBinaryNestedType[] innerTypes = typeInfo.getMemberTypes();
if (innerTypes != null) {
IPackageFragment pkg = (IPackageFragment) type.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
for (int i = 0, typeCount = innerTypes.length; i < typeCount; i++) {
IBinaryNestedType binaryType = innerTypes[i];
IClassFile parentClassFile= pkg.getClassFile(new String(ClassFile.unqualifiedName(binaryType.getName())) + SUFFIX_STRING_class);
IType innerType = new BinaryType((JavaElement) parentClassFile, ClassFile.simpleName(binaryType.getName()));
childrenHandles.add(innerType);
}
}
}
/**
* Creates the handles and infos for the methods of the given binary type.
* Adds new handles to the given vector.
*/
private void generateMethodInfos(IType type, IBinaryType typeInfo, HashMap newElements, ArrayList childrenHandles, ArrayList typeParameterHandles) {
IBinaryMethod[] methods = typeInfo.getMethods();
if (methods == null) {
return;
}
for (int i = 0, methodCount = methods.length; i < methodCount; i++) {
IBinaryMethod methodInfo = methods[i];
// TODO (jerome) filter out synthetic members
// indexer should not index them as well
// if ((methodInfo.getModifiers() & IConstants.AccSynthetic) != 0) continue; // skip synthetic
char[] signature = methodInfo.getGenericSignature();
if (signature == null) signature = methodInfo.getMethodDescriptor();
String[] pNames = null;
try {
pNames = Signature.getParameterTypes(new String(signature));
} catch (IllegalArgumentException e) {
// protect against malformed .class file (e.g. com/sun/crypto/provider/SunJCE_b.class has a 'a' generic signature)
signature = methodInfo.getMethodDescriptor();
pNames = Signature.getParameterTypes(new String(signature));
}
char[][] paramNames= new char[pNames.length][];
for (int j= 0; j < pNames.length; j++) {
paramNames[j]= pNames[j].toCharArray();
}
char[][] parameterTypes = ClassFile.translatedNames(paramNames);
JavaModelManager manager = JavaModelManager.getJavaModelManager();
String selector = new String(methodInfo.getSelector());
if (methodInfo.isConstructor()) {
selector =type.getElementName();
}
selector = manager.intern(selector);
for (int j= 0; j < pNames.length; j++) {
pNames[j]= manager.intern(new String(parameterTypes[j]));
}
BinaryMethod method = new BinaryMethod((JavaElement)type, selector, pNames);
childrenHandles.add(method);
// ensure that 2 binary methods with the same signature but with different return types have different occurence counts.
// (case of bridge methods in 1.5)
while (newElements.containsKey(method))
method.occurrenceCount++;
newElements.put(method, methodInfo);
generateTypeParameterInfos(method, signature, newElements, typeParameterHandles);
}
}
/**
* Creates the handles and infos for the type parameter of the given binary member.
* Adds new handles to the given vector.
*/
private void generateTypeParameterInfos(BinaryMember parent, char[] signature, HashMap newElements, ArrayList typeParameterHandles) {
if (signature == null) return;
char[][] typeParameterSignatures = Signature.getTypeParameters(signature);
for (int i = 0, typeParameterCount = typeParameterSignatures.length; i < typeParameterCount; i++) {
char[] typeParameterSignature = typeParameterSignatures[i];
char[] typeParameterName = Signature.getTypeVariable(typeParameterSignature);
char[][] typeParameterBoundSignatures = Signature.getTypeParameterBounds(typeParameterSignature);
int boundLength = typeParameterBoundSignatures.length;
char[][] typeParameterBounds = new char[boundLength][];
for (int j = 0; j < boundLength; j++) {
typeParameterBounds[j] = Signature.toCharArray(typeParameterBoundSignatures[j]);
CharOperation.replace(typeParameterBounds[j], '/', '.');
}
TypeParameter typeParameter = new TypeParameter(parent, new String(typeParameterName));
TypeParameterElementInfo info = new TypeParameterElementInfo();
info.bounds = typeParameterBounds;
typeParameterHandles.add(typeParameter);
// ensure that 2 binary methods with the same signature but with different return types have different occurence counts.
// (case of bridge methods in 1.5)
while (newElements.containsKey(typeParameter))
typeParameter.occurrenceCount++;
newElements.put(typeParameter, info);
}
}
/**
* Returns true iff the <code>readBinaryChildren</code> has already
* been called.
*/
boolean hasReadBinaryChildren() {
return this.binaryChildren != null;
}
/**
* Creates the handles for <code>BinaryMember</code>s defined in this
* <code>ClassFile</code> and adds them to the
* <code>JavaModelManager</code>'s cache.
*/
protected void readBinaryChildren(ClassFile classFile, HashMap newElements, IBinaryType typeInfo) {
ArrayList childrenHandles = new ArrayList();
BinaryType type = (BinaryType) classFile.getType();
ArrayList typeParameterHandles = new ArrayList();
if (typeInfo != null) { //may not be a valid class file
generateTypeParameterInfos(type, typeInfo.getGenericSignature(), newElements, typeParameterHandles);
generateFieldInfos(type, typeInfo, newElements, childrenHandles);
generateMethodInfos(type, typeInfo, newElements, childrenHandles, typeParameterHandles);
generateInnerClassHandles(type, typeInfo, childrenHandles); // Note inner class are separate openables that are not opened here: no need to pass in newElements
}
this.binaryChildren = new JavaElement[childrenHandles.size()];
childrenHandles.toArray(this.binaryChildren);
int typeParameterHandleSize = typeParameterHandles.size();
if (typeParameterHandleSize == 0) {
this.typeParameters = TypeParameter.NO_TYPE_PARAMETERS;
} else {
this.typeParameters = new ITypeParameter[typeParameterHandleSize];
typeParameterHandles.toArray(this.typeParameters);
}
}
/**
* Removes the binary children handles and remove their infos from
* the <code>JavaModelManager</code>'s cache.
*/
void removeBinaryChildren() throws JavaModelException {
if (this.binaryChildren != null) {
JavaModelManager manager = JavaModelManager.getJavaModelManager();
for (int i = 0; i <this.binaryChildren.length; i++) {
JavaElement child = this.binaryChildren[i];
if (child instanceof BinaryType) {
manager.removeInfoAndChildren((JavaElement)child.getParent());
} else {
manager.removeInfoAndChildren(child);
}
}
this.binaryChildren = JavaElement.NO_ELEMENTS;
}
if (this.typeParameters != null) {
JavaModelManager manager = JavaModelManager.getJavaModelManager();
for (int i = 0; i <this.typeParameters.length; i++) {
TypeParameter typeParameter = (TypeParameter) this.typeParameters[i];
manager.removeInfoAndChildren(typeParameter);
}
this.typeParameters = TypeParameter.NO_TYPE_PARAMETERS;
}
}
}