Exemplo n.º 1
0
 @Override
 public FunctionTypeImpl substitute(Type[] argumentTypes, Type[] parameterTypes) {
   if (argumentTypes.length != parameterTypes.length) {
     throw new IllegalArgumentException(
         "argumentTypes.length ("
             + argumentTypes.length
             + ") != parameterTypes.length ("
             + parameterTypes.length
             + ")");
   }
   if (argumentTypes.length == 0) {
     return this;
   }
   Element element = getElement();
   FunctionTypeImpl newType =
       (element instanceof ExecutableElement)
           ? new FunctionTypeImpl((ExecutableElement) element)
           : new FunctionTypeImpl((FunctionTypeAliasElement) element);
   newType.setReturnType(returnType.substitute(argumentTypes, parameterTypes));
   newType.setNormalParameterTypes(
       substitute(normalParameterTypes, argumentTypes, parameterTypes));
   newType.setOptionalParameterTypes(
       substitute(optionalParameterTypes, argumentTypes, parameterTypes));
   newType.namedParameterTypes = substitute(namedParameterTypes, argumentTypes, parameterTypes);
   return newType;
 }
Exemplo n.º 2
0
 /**
  * Determine whether the given field's type is changed when type parameters from the defining
  * type's declaration are replaced with the actual type arguments from the defining type.
  *
  * @param baseField the base field
  * @param definingType the type defining the parameters and arguments to be used in the
  *     substitution
  * @return true if the type is changed by type substitution.
  */
 private static boolean isChangedByTypeSubstitution(
     FieldElement baseField, InterfaceType definingType) {
   Type[] argumentTypes = definingType.getTypeArguments();
   if (baseField != null && argumentTypes.length != 0) {
     Type baseType = baseField.getType();
     Type[] parameterTypes = definingType.getElement().getType().getTypeArguments();
     if (baseType != null) {
       Type substitutedType = baseType.substitute(argumentTypes, parameterTypes);
       if (!baseType.equals(substitutedType)) {
         return true;
       }
     }
     // If the field has a propagated type, then we need to check whether the propagated type
     // needs substitution.
     Type basePropagatedType = baseField.getPropagatedType();
     if (basePropagatedType != null) {
       Type substitutedPropagatedType =
           basePropagatedType.substitute(argumentTypes, parameterTypes);
       if (!basePropagatedType.equals(substitutedPropagatedType)) {
         return true;
       }
     }
   }
   return false;
 }
Exemplo n.º 3
0
  @Override
  public boolean isSubtypeOf(Type type) {
    // trivial base cases
    if (type == null) {
      return false;
    } else if (this == type || type.isDynamic() || type.isDartCoreFunction()) {
      return true;
    } else if (!(type instanceof FunctionType)) {
      return false;
    } else if (this.equals(type)) {
      return true;
    }
    FunctionType t = this;
    FunctionType s = (FunctionType) type;
    // normal parameter types
    if (t.getNormalParameterTypes().length != s.getNormalParameterTypes().length) {
      return false;
    } else if (t.getNormalParameterTypes().length > 0) {
      Type[] tTypes = t.getNormalParameterTypes();
      Type[] sTypes = s.getNormalParameterTypes();
      for (int i = 0; i < tTypes.length; i++) {
        if (!tTypes[i].isAssignableTo(sTypes[i])) {
          return false;
        }
      }
    }

    // optional parameter types
    if (t.getOptionalParameterTypes().length > 0) {
      Type[] tOpTypes = t.getOptionalParameterTypes();
      Type[] sOpTypes = s.getOptionalParameterTypes();
      // if k >= m is false, return false: the passed function type has more optional parameter
      // types than this
      if (tOpTypes.length < sOpTypes.length) {
        return false;
      }
      for (int i = 0; i < sOpTypes.length; i++) {
        if (!tOpTypes[i].isAssignableTo(sOpTypes[i])) {
          return false;
        }
      }
      if (t.getNamedParameterTypes().size() > 0 || s.getNamedParameterTypes().size() > 0) {
        return false;
      }
    } else if (s.getOptionalParameterTypes().length > 0) {
      return false;
    }

    // named parameter types
    if (t.getNamedParameterTypes().size() > 0) {
      Map<String, Type> namedTypesT = t.getNamedParameterTypes();
      Map<String, Type> namedTypesS = s.getNamedParameterTypes();
      // if k >= m is false, return false: the passed function type has more named parameter types
      // than this
      if (namedTypesT.size() < namedTypesS.size()) {
        return false;
      }
      // Loop through each element in S verifying that T has a matching parameter name and that the
      // corresponding type is assignable to the type in S.
      Iterator<Entry<String, Type>> iteratorS = namedTypesS.entrySet().iterator();
      while (iteratorS.hasNext()) {
        Entry<String, Type> entryS = iteratorS.next();
        Type typeT = namedTypesT.get(entryS.getKey());
        if (typeT == null) {
          return false;
        }
        if (!entryS.getValue().isAssignableTo(typeT)) {
          return false;
        }
      }
    } else if (s.getNamedParameterTypes().size() > 0) {
      return false;
    }
    return s.getReturnType().equals(VoidTypeImpl.getInstance())
        || t.getReturnType().isAssignableTo(s.getReturnType());
  }