anchor.diff:     */
     FunctionTypeImpl(ExecutableElement element,
         [List<FunctionTypeAliasElement> prunedTypedefs])
  -      : this._(element, null, prunedTypedefs, null, null, null);
  +      : this._(element, null, prunedTypedefs, null, false);
   
     /**
      * Initialize a newly created function type to be declared by the given
      * [element], with the given [name] and [typeArguments].
  -   *
  -   * TODO(paulberry): set [typeParameters] and [boundTypeParameters] properly.
      */
     FunctionTypeImpl.elementWithNameAndArgs(
         Element element, String name, List<DartType> typeArguments)
  -      : this._(element, name, null, typeArguments,
  -            const <TypeParameterElement>[], const <TypeParameterElement>[]);
  +      : this._(element, name, null, typeArguments, false);
   
     /**
      * Initialize a newly created function type to be declared by the given
  
positive.code:     //
      // Now instantiate([V]), and the result should be:
      //     {U/T, V/S} T -> S.
      List<TypeParameterElement> newTypeParams = typeParameters.toList();
      List<DartType> newTypeArgs = typeArguments.toList();
      newTypeParams.addAll(boundTypeParameters);
      newTypeArgs.addAll(argumentTypes);
  
      return new FunctionTypeImpl._(element, name, prunedTypedefs, newTypeArgs,
          newTypeParams, TypeParameterElement.EMPTY_LIST);
    }
  
    @override
  
negative.code:   List<DartType> get typeArguments => _typeArguments;
  
    @override
    List<TypeParameterElement> get typeParameters {
      if (_typeParameters == null) {
        // Combine the generic type variables from all enclosing contexts, except
        // for this generic function's type variables. Those variables are
        // tracked in [boundTypeParameters].
        _typeParameters = <TypeParameterElement>[];
        Element e = element?.enclosingElement;
        while (e != null) {
          if (e is TypeParameterizedElement) {
            _typeParameters.addAll(e.typeParameters);
          }
          e = e.enclosingElement;
        }
        if (_isInstantiated) {
          // Once the type has been instantiated, type parameters defined at the
          // site of the declaration of the method are no longer considered part
          // [boundTypeParameters]; they are part of [typeParameters].
          List<TypeParameterElement> parametersToAdd = element?.typeParameters;
          if (parametersToAdd != null) {
            _typeParameters.addAll(parametersToAdd);
          }
        }
      }
      return _typeParameters;
    }
  
    @override
    bool operator ==(Object object) {
  