anchor.diff:          namedParameters: newNamedParameters);
     }
   
  -  List<DecoratedType> _substituteList(List<DecoratedType> list,
  -      Map<TypeParameterElement, DecoratedType> substitution) {
  -    return list.map((t) => t.substitute(substitution)).toList();
  -  }
  -
  -  Map<String, DecoratedType> _substituteMap(Map<String, DecoratedType> map,
  -      Map<TypeParameterElement, DecoratedType> substitution) {
  -    var result = <String, DecoratedType>{};
  -    for (var entry in map.entries) {
  -      result[entry.key] = entry.value.substitute(substitution);
  -    }
  -    return result;
  -  }
  -
     /// Retrieves the decorated bound of the given [typeParameter].
     ///
     /// [typeParameter] must have an enclosing element of `null`.  Type parameters
  
positive.code:     }
      return true;
    }
  
    static bool _compareTypeFormalLists(List<TypeParameterElement> formals1,
        List<TypeParameterElement> formals2) {
      if (identical(formals1, formals2)) return true;
      if (formals1.length != formals2.length) return false;
      for (int i = 0; i < formals1.length; i++) {
        if (!identical(formals1[i], formals2[i])) return false;
      }
      return true;
    }
  }
  
negative.code:         if (thisType.typeFormals.length != otherType.typeFormals.length) {
            return false;
          }
          var renamed = RenamedDecoratedFunctionTypes.match(
              this, other, (bound1, bound2) => bound1 == bound2);
          if (renamed == null) return false;
          if (renamed.returnType1 != renamed.returnType2) return false;
          if (!_compareLists(
              renamed.positionalParameters1, renamed.positionalParameters2)) {
            return false;
          }
          if (!_compareMaps(renamed.namedParameters1, renamed.namedParameters2)) {
            return false;
          }
          return true;
  