anchor.diff:  
     @override
     List<DartType> get optionalParameterTypes {
  -    List<ParameterElement> parameters = baseParameters;
  -    if (parameters.length == 0) {
  -      return DartType.EMPTY_LIST;
  -    }
  -    List<DartType> typeParameters =
  -        TypeParameterTypeImpl.getTypes(this.typeParameters);
  -    List<DartType> types = new List<DartType>();
  -    for (ParameterElement parameter in parameters) {
  -      if (parameter.parameterKind == ParameterKind.POSITIONAL) {
  -        DartType type = parameter.type;
  -        if (typeArguments.length != 0 &&
  -            typeArguments.length == typeParameters.length) {
  -          type = (type as TypeImpl)
  -              .substitute2(typeArguments, typeParameters, newPrune);
  -        } else {
  -          type = (type as TypeImpl).pruned(newPrune);
  -        }
  -        types.add(type);
  -      }
  -    }
  +    List<DartType> types = <DartType>[];
  +    _forEachParameterType(ParameterKind.POSITIONAL, (name, type) {
  +      types.add(type);
  +    });
       return types;
     }
   
  
positive.code: 
    @override
    List<DartType> get normalParameterTypes {
      List<ParameterElement> parameters = baseParameters;
      if (parameters.length == 0) {
        return DartType.EMPTY_LIST;
      }
      List<DartType> typeParameters =
          TypeParameterTypeImpl.getTypes(this.typeParameters);
      List<DartType> types = new List<DartType>();
      for (ParameterElement parameter in parameters) {
        if (parameter.parameterKind == ParameterKind.REQUIRED) {
          DartType type = parameter.type;
          if (typeArguments.length != 0 &&
              typeArguments.length == typeParameters.length) {
            type = (type as TypeImpl)
                .substitute2(typeArguments, typeParameters, newPrune);
          } else {
            type = (type as TypeImpl).pruned(newPrune);
          }
          types.add(type);
        }
      }
      return types;
    }
  
  
negative.code:     } else if (this == type) {
        return true;
      }
  
      FunctionType s = type as FunctionType;
      List<DartType> tRequired = normalParameterTypes;
      List<DartType> sRequired = s.normalParameterTypes;
      List<DartType> tOptional = optionalParameterTypes;
      List<DartType> sOptional = s.optionalParameterTypes;
      Map<String, DartType> tNamed = namedParameterTypes;
      Map<String, DartType> sNamed = s.namedParameterTypes;
  
      // If one function has positional and the other has named parameters,
      // they don't relate.
      if (sOptional.isNotEmpty && tNamed.isNotEmpty ||
          tOptional.isNotEmpty && sNamed.isNotEmpty) {
        return false;
      }
  
      // If the passed function includes more named parameters than we do, we
      // don't relate.
      if (tNamed.length < sNamed.length) {
        return false;
      }
  
      // For each named parameter in s, make sure we have a corresponding one
      // that relates.
      for (String key in sNamed.keys) {
        var tParamType = tNamed[key];
        if (tParamType == null) {
          return false;
        }
        if (!relation(tParamType, sNamed[key])) {
          return false;
        }
      }
  
      // Make sure all of the positional parameters (both required and optional)
      // relate to each other.
      List<DartType> tPositional = tRequired;
      List<DartType> sPositional = sRequired;
  
      if (tOptional.isNotEmpty) {
        tPositional = tPositional.toList()..addAll(tOptional);
      }
  
      if (sOptional.isNotEmpty) {
        sPositional = sPositional.toList()..addAll(sOptional);
      }
  
      // Check that s has enough required parameters.
      if (sRequired.length < tRequired.length) {
        return false;
      }
  
      // Check that s does not include more positional parameters than we do.
      if (tPositional.length < sPositional.length) {
        return false;
      }
  
      for (int i = 0; i < sPositional.length; i++) {
        if (!relation(tPositional[i], sPositional[i])) {
          return false;
        }
      }
  
      DartType sRetType = s.returnType;
      return sRetType.isVoid || relation(returnType, sRetType);
    }
  
    @override
  