dev/core/src/com/google/gwt/dev/javac/typemodel/AssignabilityChecker.java

/*
 * Copyright 2014 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.dev.javac.typemodel;

import com.google.gwt.core.ext.typeinfo.JType;

import java.util.Set;

/**
 * A helper class to check assignability of types.
 */
class AssignabilityChecker {

  public boolean isAssignable(JClassType from, JClassType to) {
    from = convertToRawIfGeneric(from);
    to = convertToRawIfGeneric(to);

    if (to == from) {
      return true;
    }

    if (to.isWildcard() != null) {
      return isAssignableToWildcardType(from, to.isWildcard());
    }

    if (from.isTypeParameter() != null) {
      return isAssignableFromAny(from.isTypeParameter().getBounds(), to);
    }

    if (from.isWildcard() != null) {
      return isAssignableFromAny(from.isWildcard().getUpperBounds(), to);
    }

    if (from.isArray() != null) {
      return isAssignableFromGenericArrayType(from.isArray(), to);
    }

    if (to.isParameterized() != null) {
      return isAssignableToParameterizedType(from, to.isParameterized());
    }

    if (to.isTypeParameter() != null) {
      // type inference is not supported (yet)
      return isAssignableFromAll(from, to.isTypeParameter().getBounds());
    }

    if (to.isArray() != null) {
      return false;
    }

    // Only remaining cases for 'to' are being real-class or raw type
    assert to instanceof JRealClassType || to instanceof JRawType;

    return isAssignableFromRaw(from, to);
  }

  private boolean isAssignableFromAny(JClassType[] fromTypes, JClassType to) {
    for (JClassType from : fromTypes) {
      if (isAssignable(from, to)) {
        return true;
      }
    }
    return false;
  }

  private boolean isAssignableToWildcardType(JClassType from, JWildcardType to) {
    // if "to" is <? extends Foo>, "from" can be:
    // Foo, SubFoo, <? extends Foo>, <? extends SubFoo>, <T extends Foo> or <T extends SubFoo>.
    // if "to" is <? super Foo>, "from" can be:
    // Foo, SuperFoo, <? super Foo> or <? super SuperFoo>.
    return isAssignable(from, supertypeBound(to)) && isAssignableBySubtypeBound(from, to);
  }

  private boolean isAssignableBySubtypeBound(JClassType from, JWildcardType to) {
    JClassType toSubtypeBound = subtypeBound(to);
    if (toSubtypeBound == null) {
      return true;
    }
    JClassType fromSubtypeBound = subtypeBound(from);
    if (fromSubtypeBound == null) {
      return false;
    }
    return isAssignable(toSubtypeBound, fromSubtypeBound);
  }

  private boolean isAssignableToParameterizedType(JClassType from, JParameterizedType to) {
    // If "to" is "List<? extends CharSequence>" and "from" is StringArrayList,
    // First step is to figure out StringArrayList "is-a" List<E> and <E> is String.
    JMaybeParameterizedType parentOfFrom = asParamterizationOf(from, to);
    if (parentOfFrom == null) {
      return false;
    }

    if (parentOfFrom.isRawType() != null) {
      return true;
    }

    // If it is not raw, then it should be parameterized
    JParameterizedType parameterizedParentOfFrom = parentOfFrom.isParameterized();
    assert parameterizedParentOfFrom != null;

    JClassType[] fromTypeArgs = parameterizedParentOfFrom.getTypeArgs();
    JClassType[] toTypeArgs = to.getTypeArgs();
    for (int i = 0; i < fromTypeArgs.length; i++) {
      if (!matchTypeArgument(fromTypeArgs[i], toTypeArgs[i])) {
        return false;
      }
    }
    return true;
  }

  private boolean matchTypeArgument(JClassType from, JClassType to) {
    if (from == to) {
      return true;
    }

    if (to.isWildcard() != null) {
      return isAssignableToWildcardType(from, to.isWildcard());
    }

    return false;
  }

  private boolean isAssignableFromAll(JClassType from, JClassType[] toTypes) {
    for (JClassType to : toTypes) {
      if (!isAssignable(from, to)) {
        return false;
      }
    }
    return true;
  }

  private boolean isAssignableFromGenericArrayType(JArrayType from, JClassType to) {
    if (to.isArray() != null) {

      JType fromComponentType = from.getComponentType();
      JType toComponentType = to.isArray().getComponentType();

      if (toComponentType.isPrimitive() != null || fromComponentType.isPrimitive() != null) {
        // Only scenario for this to be assignable is; this two being equal, but we wouldn't have
        // reached here in that case
        return false;
      }

      return isAssignable((JClassType) fromComponentType, (JClassType) toComponentType);
    }

    return isJavaLangObject(to);
  }

  private boolean isAssignableFromRaw(JClassType from, JClassType to) {
    if (isJavaLangObject(to)) {
      return true;
    }

    Set<JClassType> fromSuperTypeHierarchy = from.getFlattenedSupertypeHierarchy();

    // Shortcut: 'to' is one of the parents.
    if (fromSuperTypeHierarchy.contains(to)) {
      return true;
    }

    // Fallback to checking erased types if it is raw.
    if (to.isRawType() != null) {
      for (JClassType fromSuper : fromSuperTypeHierarchy) {
        if (fromSuper.getErasedType() == to.getErasedType()) {
          return true;
        }
      }
    }

    return false;
  }

  private static boolean isJavaLangObject(JClassType type) {
    return type == type.getOracle().getJavaLangObject();
  }

  private static JClassType convertToRawIfGeneric(JClassType from) {
    return from.isGenericType() != null ? from.isGenericType().getRawType() : from;
  }

  private static JClassType supertypeBound(JWildcardType type) {
    // If type is <? super ? super Foo>, this will return Foo.
    // (Even if you cannot write such code in java, the type can resolve to that)
    JClassType upperBound = type.getUpperBound();
    return upperBound.isWildcard() != null ? supertypeBound(upperBound.isWildcard()) : upperBound;
  }

  private static JClassType subtypeBound(JWildcardType type) {
    // If type is <? extends ? extends Foo>, this will return Foo.
    // (Even if you cannot write such code in java, the type can resolve to that)
    JClassType[] lowerBounds = type.getLowerBounds();
    return lowerBounds.length == 1 ? subtypeBound(lowerBounds[0]) : null;
  }

  private static JClassType subtypeBound(JClassType type) {
    return type.isWildcard() != null ? subtypeBound(type.isWildcard()) : type;
  }

  private static JMaybeParameterizedType asParamterizationOf(JClassType from,
      JParameterizedType to) {
    for (JClassType parent : from.getFlattenedSupertypeHierarchy()) {
      JMaybeParameterizedType maybeParameterized = parent.isMaybeParameterizedType();
      if (maybeParameterized != null && maybeParameterized.getBaseType() == to.getBaseType()) {
        return maybeParameterized;
      }
    }
    return null;
  }
}