tools/api-checker/src/com/google/gwt/tools/apichecker/ApiMethod.java

/*
 * 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.typeinfo.JAbstractMethod;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Encapsulates an API method. Useful for set-operations.
 */
final class ApiMethod extends ApiAbstractMethod {

  ApiMethod(JAbstractMethod method, ApiClass apiClass) {
    super(method, apiClass);
  }

  @Override
  public boolean isOverridable() {
    JMethod methodType = (JMethod) method;
    if (methodType.isStatic() || methodType.isFinal()) {
      return false;
    }
    return apiClass.isSubclassableApiClass();
  }

  @Override
  ApiChange checkReturnTypeCompatibility(ApiAbstractMethod newMethod)
      throws TypeNotPresentException {
    JType firstType, secondType;
    if (newMethod.getMethod() instanceof JMethod && method instanceof JMethod) {
      firstType = ((JMethod) method).getReturnType();
      secondType = ((JMethod) newMethod.getMethod()).getReturnType();
    } else {
      throw new AssertionError("Different types for method = " + method.getClass()
          + ", and newMethodObject = " + newMethod.getMethod().getClass() + ", signature = "
          + getApiSignature());
    }
    StringBuffer sb = new StringBuffer();
    if (firstType.getSimpleSourceName().indexOf("void") != -1) {
      return null;
    }
    boolean compatible = ApiDiffGenerator.isFirstTypeAssignableToSecond(secondType, firstType);
    if (compatible) {
      return null;
    }
    sb.append(" from ");
    sb.append(firstType.getQualifiedSourceName());
    sb.append(" to ");
    sb.append(secondType.getQualifiedSourceName());
    return new ApiChange(this, ApiChange.Status.RETURN_TYPE_ERROR, sb.toString());
  }

  /**
   * check for changes in: (i) argument types, (ii) return type, (iii)
   * exceptions thrown. use getJNISignature() for type equality, it does type
   * erasure
   */
  @Override
  List<ApiChange> getAllChangesInApi(ApiAbstractMethod newApiMethod) {
    if (!(newApiMethod.getMethod() instanceof JMethod)) {
      return Collections.emptyList();
    }
    List<ApiChange> changeApis = new ArrayList<ApiChange>();
    JMethod existingMethod = (JMethod) method;
    JMethod newMethod = (JMethod) newApiMethod.getMethod();
    // check return type
    if (!existingMethod.getReturnType().getJNISignature().equals(
        newMethod.getReturnType().getJNISignature())) {
      changeApis.add(new ApiChange(this, ApiChange.Status.OVERRIDABLE_METHOD_RETURN_TYPE_CHANGE,
          " from " + existingMethod.getReturnType() + " to " + newMethod.getReturnType()));
    }
    // check argument type
    JParameter[] newParametersList = newMethod.getParameters();
    JParameter[] existingParametersList = existingMethod.getParameters();
    if (newParametersList.length != existingParametersList.length) {
      changeApis.add(new ApiChange(this, ApiChange.Status.OVERRIDABLE_METHOD_ARGUMENT_TYPE_CHANGE,
          "number of parameters changed"));
    } else {
      int length = newParametersList.length;
      for (int i = 0; i < length; i++) {
        if (!existingParametersList[i].getType().getJNISignature().equals(
            newParametersList[i].getType().getJNISignature())) {
          changeApis.add(new ApiChange(this,
              ApiChange.Status.OVERRIDABLE_METHOD_ARGUMENT_TYPE_CHANGE, " at position " + i
                  + " from " + existingParametersList[i].getType() + " to "
                  + newParametersList[i].getType()));
        }
      }
    }

    // check exceptions
    Set<String> newExceptionsSet = new HashSet<String>();
    Map<String, JType> newExceptionsMap = new HashMap<String, JType>();
    for (JType newType : newMethod.getThrows()) {
      String jniSignature = newType.getJNISignature();
      newExceptionsMap.put(jniSignature, newType);
      newExceptionsSet.add(jniSignature);
    }

    Set<String> existingExceptionsSet = new HashSet<String>();
    Map<String, JType> existingExceptionsMap = new HashMap<String, JType>();
    for (JType existingType : existingMethod.getThrows()) {
      String jniSignature = existingType.getJNISignature();
      existingExceptionsMap.put(jniSignature, existingType);
      existingExceptionsSet.add(jniSignature);
    }
    ApiDiffGenerator.removeIntersection(existingExceptionsSet, newExceptionsSet);
    removeUncheckedExceptions(newMethod, newExceptionsSet, newExceptionsMap);
    removeUncheckedExceptions(existingMethod, existingExceptionsSet, existingExceptionsMap);
    if (existingExceptionsSet.size() > 0) {
      changeApis.add(new ApiChange(this, ApiChange.Status.OVERRIDABLE_METHOD_EXCEPTION_TYPE_CHANGE,
          "existing method had more exceptions: " + existingExceptionsSet));
    }
    if (newExceptionsSet.size() > 0) {
      changeApis.add(new ApiChange(this, ApiChange.Status.OVERRIDABLE_METHOD_EXCEPTION_TYPE_CHANGE,
          "new method has more exceptions: " + newExceptionsSet));
    }
    return changeApis;
  }

  /*
   * check for: (i) added 'final' or 'abstract', (ii) removed 'static', adding
   * the 'static' keyword is fine.
   * 
   * A private, static, or final method can't be made 'abstract' (Java language
   * specification).
   */
  @Override
  List<ApiChange.Status> getModifierChanges(final ApiAbstractMethod newMethod) {
    JMethod newjmethod = null;
    JMethod oldjmethod = null;

    if (newMethod.getMethod() instanceof JMethod && method instanceof JMethod) {
      newjmethod = (JMethod) newMethod.getMethod();
      oldjmethod = (JMethod) method;
    } else {
      throw new AssertionError("Different types for method = " + method.getClass()
          + " and newMethod = " + newMethod.getMethod().getClass() + ", signature = "
          + getApiSignature());
    }
    List<ApiChange.Status> statuses = new ArrayList<ApiChange.Status>();
    if (!oldjmethod.isFinal() && !apiClass.getClassObject().isFinal() && newjmethod.isFinal()) {
      statuses.add(ApiChange.Status.FINAL_ADDED);
    }
    if (!oldjmethod.isAbstract() && newjmethod.isAbstract()) {
      statuses.add(ApiChange.Status.ABSTRACT_ADDED);
    }
    if ((oldjmethod.isStatic() && !newjmethod.isStatic())) {
      statuses.add(ApiChange.Status.STATIC_REMOVED);
    }
    return statuses;
  }

  // remove Error.class, RuntimeException.class, and their sub-classes
  private void removeUncheckedExceptions(JMethod method, Set<String> exceptionsSet,
      Map<String, JType> exceptionsMap) {
    if (exceptionsSet.size() == 0) {
      return;
    }
    TypeOracle typeOracle = method.getEnclosingType().getOracle();
    JClassType errorType = typeOracle.findType(Error.class.getName());
    JClassType rteType = typeOracle.findType(RuntimeException.class.getName());
    Set<String> exceptionsToRemove = new HashSet<String>();
    for (String exceptionString : exceptionsSet) {
      JType exception = exceptionsMap.get(exceptionString);
      assert (exception != null);
      boolean remove =
          (errorType != null && ApiDiffGenerator
              .isFirstTypeAssignableToSecond(exception, errorType))
              || (rteType != null && ApiDiffGenerator.isFirstTypeAssignableToSecond(exception,
                  rteType));
      if (remove) {
        exceptionsToRemove.add(exceptionString);
      }
    }
    exceptionsSet.removeAll(exceptionsToRemove);
  }
}
/*
 * final class TestB { static protected int i = 5; }
 * 
 * class TestC { public int j = TestB.i + 10; }
 */