anchor.diff:    }
   
     test_promoteToNonNull_typeParameter_questionBound_question() {
  -    var element = _typeParameter('T', bound: stringClassTypeQuestion);
  -    var type = _typeParameterType(
  -      element,
  -      nullabilitySuffix: NullabilitySuffix.question,
  -    );
  +    var element = typeParameter('T', bound: stringClassTypeQuestion);
  +    var type = typeParameterTypeQuestion(element);
       _assertPromotedTypeParameterType(
         typeSystem.promoteToNonNull(type),
         baseElement: element,
  
positive.code: 
    void test_returnFunctionWithGenericParameterAndReturn() {
      // <T>(T -> T) -> (T -> T)
      var T = _typeParameter('T');
      var f = _functionType(
        typeFormals: [T],
        required: [
          _functionType(
            required: [
              _typeParameterType(T),
            ],
            returns: _typeParameterType(T),
          )
        ],
        returns: _functionType(
          required: [
            _typeParameterType(T),
          ],
          returns: _typeParameterType(T),
        ),
      );
      expect(
        _inferCall(f, [
          _functionType(
            required: [numType],
            returns: intType,
          )
        ]),
        [intType],
  
negative.code: 
    void test_genericCastFunction() {
      // <TFrom, TTo>(TFrom) -> TTo
      var tFrom = typeParameter('TFrom');
      var tTo = typeParameter('TTo');
      var cast = functionTypeStar(
        typeFormals: [tFrom, tTo],
        parameters: [
          requiredParameter(
            type: typeParameterTypeStar(tFrom),
          ),
        ],
        returnType: typeParameterTypeStar(tTo),
      );
      expect(_inferCall(cast, [intType]), [intType, dynamicType]);
    }
  
    void test_genericCastFunctionWithUpperBound() {
      // <TFrom, TTo extends TFrom>(TFrom) -> TTo
      var tFrom = typeParameter('TFrom');
      var tTo = typeParameter(
        'TTo',
        bound: typeParameterTypeStar(tFrom),
      );
      var cast = functionTypeStar(
        typeFormals: [tFrom, tTo],
        parameters: [
          requiredParameter(
            type: typeParameterTypeStar(tFrom),
          ),
        ],
        returnType: typeParameterTypeStar(tTo),
      );
      expect(_inferCall(cast, [intType]), [intType, intType]);
    }
  
    void test_parametersToFunctionParam() {
      // <T>(f(T t)) -> T
      var T = typeParameter('T');
      var cast = functionTypeStar(
        typeFormals: [T],
        parameters: [
          requiredParameter(
            type: functionTypeStar(
              parameters: [
                requiredParameter(
                  type: typeParameterTypeStar(T),
                ),
              ],
              returnType: dynamicType,
            ),
          ),
        ],
        returnType: typeParameterTypeStar(T),
      );
      expect(
        _inferCall(cast, [
          functionTypeStar(
            parameters: [
              requiredParameter(type: numType),
            ],
            returnType: dynamicType,
          )
        ]),
        [numType],
  