/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.tools.apichecker;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JMethod;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Encapsulates an API class.
*/
final class ApiClass implements Comparable<ApiClass>, ApiElement {
/**
* Enum for indexing the common storage used for methods and constructors
*
*/
public static enum MethodType {
CONSTRUCTOR, METHOD;
}
private HashMap<String, ApiField> apiFields = null;
/**
* TODO (amitmanjhi): Toby felt that combining structures for storing
* MethodType and Constructors was unnecessary. In particular, the hashMap of
* name#args -> object is meaningless for constructor, since name is empty for
* constructors. Make it separate.
*
* In addition, the current method fails when constructors or methods accept
* variable arguments. In future, just index everything by name [and not add
* the number of arguments that they accept].
*/
/**
* 2 entries in the list: one for CONSTRUCTOR, and the other for METHOD. Each
* entry is a mapping from MethodName#args to a set of ApiAbstractMethod
*/
private EnumMap<MethodType, Map<String, Set<ApiAbstractMethod>>> apiMembersByName = null;
private final ApiPackage apiPackage;
private final JClassType classType;
private final boolean isInstantiableApiClass;
private final boolean isNotsubclassableApiClass;
private final boolean isSubclassableApiClass;
private final TreeLogger logger;
ApiClass(JClassType classType, ApiPackage apiPackage) {
this.classType = classType;
this.apiPackage = apiPackage;
logger = apiPackage.getApiContainer().getLogger();
ApiContainer apiContainer = apiPackage.getApiContainer();
isSubclassableApiClass = apiContainer.isSubclassableApiClass(classType);
isNotsubclassableApiClass = apiContainer.isNotsubclassableApiClass(classType);
isInstantiableApiClass = apiContainer.isInstantiableApiClass(classType);
}
public int compareTo(ApiClass other) {
return getName().compareTo(other.getName());
}
@Override
public boolean equals(Object o) {
if (!(o instanceof ApiClass)) {
return false;
}
return this.getName().equals(((ApiClass) o).getName());
}
public String getRelativeSignature() {
return classType.getQualifiedSourceName();
}
@Override
public int hashCode() {
return this.getName().hashCode();
}
@Override
public String toString() {
return classType.toString();
}
String getApiAsString() {
StringBuffer sb = new StringBuffer();
sb.append("\t" + getName() + "\n");
if (apiFields != null) {
ArrayList<ApiField> apiFieldsList = new ArrayList<ApiField>(apiFields.values());
Collections.sort(apiFieldsList);
for (ApiField apiField : apiFieldsList) {
sb.append("\t\t" + apiField.getRelativeSignature() + "\n");
}
}
if (apiMembersByName != null && apiMembersByName.get(MethodType.METHOD) != null) {
for (MethodType method : MethodType.values()) {
HashSet<ApiAbstractMethod> apiMethodsSet = new HashSet<ApiAbstractMethod>();
for (Set<ApiAbstractMethod> methodsSets : apiMembersByName.get(method).values()) {
apiMethodsSet.addAll(methodsSets);
}
ArrayList<ApiAbstractMethod> apiMethodsList =
new ArrayList<ApiAbstractMethod>(apiMethodsSet);
Collections.sort(apiMethodsList);
for (ApiAbstractMethod apiMethod : apiMethodsList) {
sb.append("\t\t" + apiMethod.getRelativeSignature() + "\n");
}
}
}
return sb.toString();
}
ApiField getApiFieldByName(String name) {
return apiFields.get(name);
}
Set<String> getApiFieldNames() {
if (apiFields == null) {
initializeApiFields();
}
return new HashSet<String>(apiFields.keySet());
}
Set<ApiField> getApiFieldsBySet(Set<String> names) {
Set<ApiField> ret = new HashSet<ApiField>();
for (String name : names) {
ret.add(apiFields.get(name));
}
return ret;
}
Set<String> getApiMemberNames(MethodType type) {
if (apiMembersByName == null) {
initializeApiConstructorsAndMethods();
}
return new HashSet<String>(apiMembersByName.get(type).keySet());
}
Set<ApiAbstractMethod> getApiMembersBySet(Set<String> methodNames, MethodType type) {
Map<String, Set<ApiAbstractMethod>> current = apiMembersByName.get(type);
Set<ApiAbstractMethod> tempMethods = new HashSet<ApiAbstractMethod>();
for (String methodName : methodNames) {
tempMethods.addAll(current.get(methodName));
}
return tempMethods;
}
Set<ApiAbstractMethod> getApiMethodsByName(String name, MethodType type) {
return apiMembersByName.get(type).get(name);
}
JClassType getClassObject() {
return classType;
}
String getFullName() {
return classType.getQualifiedSourceName();
}
/**
* compute the modifier changes. check for: (i) added 'final' or 'abstract' or
* 'static' (ii) removed 'static' or 'non-abstract class made into interface'
* (if a non-abstract class is made into interface, the client class/interface
* inheriting from it would need to change)
*/
List<ApiChange.Status> getModifierChanges(ApiClass newClass) {
JClassType newClassType = newClass.getClassObject();
List<ApiChange.Status> statuses = new ArrayList<ApiChange.Status>(5);
// check for addition of 'final', 'abstract', 'static'
if (!classType.isFinal() && newClassType.isFinal()) {
statuses.add(ApiChange.Status.FINAL_ADDED);
}
if (!classType.isAbstract() && newClassType.isAbstract()) {
statuses.add(ApiChange.Status.ABSTRACT_ADDED);
}
if (!classType.isStatic() && newClassType.isStatic()) {
statuses.add(ApiChange.Status.STATIC_ADDED);
}
// removed 'static'
if (classType.isStatic() && !newClassType.isStatic()) {
statuses.add(ApiChange.Status.STATIC_REMOVED);
}
if (!classType.isAbstract() && (newClassType.isInterface() != null)) {
statuses.add(ApiChange.Status.NONABSTRACT_CLASS_MADE_INTERFACE);
}
if (apiPackage.getApiContainer().isSubclassableApiClass(classType)) {
if ((classType.isClass() != null) && (newClassType.isInterface() != null)) {
statuses.add(ApiChange.Status.SUBCLASSABLE_API_CLASS_MADE_INTERFACE);
}
if ((classType.isInterface() != null) && (newClassType.isClass() != null)) {
statuses.add(ApiChange.Status.SUBCLASSABLE_API_INTERFACE_MADE_CLASS);
}
}
return statuses;
}
String getName() {
return classType.getName();
}
ApiPackage getPackage() {
return apiPackage;
}
void initializeApiFields() {
apiFields = new HashMap<String, ApiField>();
List<String> notAddedFields = new ArrayList<String>();
JField fields[] = getAccessibleFields();
for (JField field : fields) {
if (isApiMember(field)) {
apiFields.put(field.getName(), new ApiField(field, this));
} else {
notAddedFields.add(field.toString());
}
}
if (notAddedFields.size() > 0) {
logger.log(TreeLogger.SPAM, "class " + getName() + " " + ", not adding "
+ notAddedFields.size() + " nonApi fields: " + notAddedFields, null);
}
}
boolean isSubclassableApiClass() {
return isSubclassableApiClass;
}
private JField[] getAccessibleFields() {
Map<String, JField> fieldsBySignature = new HashMap<String, JField>();
JClassType tempClassType = classType;
do {
JField declaredFields[] = tempClassType.getFields();
for (JField field : declaredFields) {
if (field.isPrivate()) {
continue;
}
String signature = field.toString();
JField existing = fieldsBySignature.put(signature, field);
if (existing != null) {
// TODO(amitmanjhi): Consider whether this is sufficient
fieldsBySignature.put(signature, existing);
}
}
tempClassType = tempClassType.getSuperclass();
} while (tempClassType != null);
return fieldsBySignature.values().toArray(new JField[0]);
}
// TODO(amitmanjhi): to optimize, cache results
private JMethod[] getAccessibleMethods() {
boolean isInterface = false;
if (classType.isInterface() != null) {
isInterface = true;
}
Map<String, JMethod> methodsBySignature = new HashMap<String, JMethod>();
LinkedList<JClassType> classesToBeProcessed = new LinkedList<JClassType>();
classesToBeProcessed.add(classType);
JClassType tempClassType = null;
while (classesToBeProcessed.peek() != null) {
tempClassType = classesToBeProcessed.remove();
JMethod declaredMethods[] = tempClassType.getMethods();
for (JMethod method : declaredMethods) {
if (method.isPrivate()) {
continue;
}
String signature = ApiAbstractMethod.computeInternalSignature(method);
JMethod existing = methodsBySignature.put(signature, method);
if (existing != null) {
// decide which implementation to keep
if (existing.getEnclosingType().isAssignableTo(method.getEnclosingType())) {
methodsBySignature.put(signature, existing);
}
}
}
if (isInterface) {
classesToBeProcessed.addAll(Arrays.asList(tempClassType.getImplementedInterfaces()));
} else {
classesToBeProcessed.add(tempClassType.getSuperclass());
}
}
return methodsBySignature.values().toArray(new JMethod[0]);
}
private JAbstractMethod[] getAccessibleMethods(MethodType member) {
switch (member) {
case CONSTRUCTOR:
return classType.getConstructors();
case METHOD:
return getAccessibleMethods();
}
throw new AssertionError("Unknown value : " + member);
}
private void initializeApiConstructorsAndMethods() {
apiMembersByName =
new EnumMap<MethodType, Map<String, Set<ApiAbstractMethod>>>(MethodType.class);
for (MethodType method : MethodType.values()) {
apiMembersByName.put(method, new HashMap<String, Set<ApiAbstractMethod>>());
Map<String, Set<ApiAbstractMethod>> pointer = apiMembersByName.get(method);
List<String> notAddedMembers = new ArrayList<String>();
JAbstractMethod jams[] = getAccessibleMethods(method);
for (JAbstractMethod jam : jams) {
if (isApiMember(jam)) {
String tempName = jam.getName() + jam.getParameters().length;
Set<ApiAbstractMethod> existingMembers = pointer.get(tempName);
if (existingMembers == null) {
existingMembers = new HashSet<ApiAbstractMethod>();
}
switch (method) {
case CONSTRUCTOR:
existingMembers.add(new ApiConstructor(jam, this));
break;
case METHOD:
existingMembers.add(new ApiMethod(jam, this));
break;
default:
throw new AssertionError("Unknown memberType : " + method);
}
pointer.put(tempName, existingMembers);
} else {
notAddedMembers.add(jam.toString());
}
}
if (notAddedMembers.size() > 0) {
logger.log(TreeLogger.SPAM, "class " + getName() + ", removing " + notAddedMembers.size()
+ " nonApi members: " + notAddedMembers, null);
}
}
}
/**
* Note: Instance members of a class that is not instantiable are not api
* members.
*/
private boolean isApiMember(final Object member) {
boolean isPublic = false;
boolean isPublicOrProtected = false;
boolean isStatic = false;
if (member instanceof JField) {
JField field = (JField) member;
isPublic = field.isPublic();
isPublicOrProtected = isPublic || field.isProtected();
isStatic = field.isStatic();
}
if (member instanceof JAbstractMethod) {
JAbstractMethod method = (JAbstractMethod) member;
isPublic = method.isPublic();
isPublicOrProtected = isPublic || method.isProtected();
if (method instanceof JMethod) {
JMethod temp = (JMethod) method;
isStatic = temp.isStatic();
} else {
isStatic = false; // constructors can't be static
}
}
if (ApiCompatibilityChecker.REMOVE_NON_SUBCLASSABLE_ABSTRACT_CLASS_FROM_API) {
if (!isInstantiableApiClass && !isStatic && !isSubclassableApiClass) {
return false;
}
}
return (isSubclassableApiClass && isPublicOrProtected)
|| (isNotsubclassableApiClass && isPublic);
}
}