anchor.diff:    }
   
     void test_isAssignableTo_named_optional() {
  -    var r = _functionType(required: [intType], returns: intType);
  -    var o = _functionType(optional: [intType], returns: intType);
  -    var n = _functionType(named: {'x': intType}, returns: intType);
  -
  -    var rr = _functionType(
  -      required: [intType, intType],
  -      returns: intType,
  -    );
  -    var ro = _functionType(
  -      required: [intType],
  -      optional: [intType],
  -      returns: intType,
  -    );
  -    var rn = _functionType(
  -      required: [intType],
  -      named: {'x': intType},
  -      returns: intType,
  -    );
  -    var oo = _functionType(
  -      optional: [intType, intType],
  -      returns: intType,
  -    );
  -    var nn = _functionType(
  -      named: {'x': intType, 'y': intType},
  -      returns: intType,
  -    );
  -    var nnn = _functionType(
  -      named: {'x': intType, 'y': intType, 'z': intType},
  -      returns: intType,
  +    var r = functionTypeStar(
  +      parameters: [
  +        requiredParameter(type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var o = functionTypeStar(
  +      parameters: [
  +        positionalParameter(type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var n = functionTypeStar(
  +      parameters: [
  +        namedParameter(name: 'x', type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +
  +    var rr = functionTypeStar(
  +      parameters: [
  +        requiredParameter(type: intType),
  +        requiredParameter(type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var ro = functionTypeStar(
  +      parameters: [
  +        requiredParameter(type: intType),
  +        positionalParameter(type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var rn = functionTypeStar(
  +      parameters: [
  +        requiredParameter(type: intType),
  +        namedParameter(name: 'x', type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var oo = functionTypeStar(
  +      parameters: [
  +        positionalParameter(type: intType),
  +        positionalParameter(type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var nn = functionTypeStar(
  +      parameters: [
  +        namedParameter(name: 'x', type: intType),
  +        namedParameter(name: 'y', type: intType),
  +      ],
  +      returnType: intType,
  +    );
  +    var nnn = functionTypeStar(
  +      parameters: [
  +        namedParameter(name: 'x', type: intType),
  +        namedParameter(name: 'y', type: intType),
  +        namedParameter(name: 'z', type: intType),
  +      ],
  +      returnType: intType,
       );
   
       _checkGroups(r,
  
positive.code:     _checkOrdinarySubtypeMatch(objectType, dynamicType, [T], covariant: true);
      _checkOrdinarySubtypeMatch(nullType, dynamicType, [T], covariant: true);
      _checkOrdinarySubtypeMatch(
        _functionType(required: [intType], returns: stringType),
        dynamicType,
        [T],
        covariant: true,
  
negative.code:     // Regression test for https://github.com/dart-lang/sdk/issues/25740.
  
      // class A {}
      var A = class_(name: 'A', superType: objectType);
      var typeA = interfaceType(A);
  
      // class B extends A {}
      var B = class_(name: 'B', superType: typeA);
      var typeB = interfaceType(B);
  
      // class C<T extends A> {
      var CT = typeParameter('T', bound: typeA);
      var C = class_(
        name: 'C',
        superType: objectType,
        typeParameters: [CT],
      );
      //   S m<S extends T>(S);
      var S = typeParameter('S', bound: typeParameterTypeStar(CT));
      var m = method(
        'm',
        typeParameterTypeStar(S),
        typeFormals: [S],
        parameters: [
          requiredParameter(
            name: '_',
            type: typeParameterTypeStar(S),
          ),
        ],
      );
      C.methods = [m];
      // }
  
      // C<Object> cOfObject;
      var cOfObject = interfaceType(C, typeArguments: [objectType]);
      // C<A> cOfA;
      var cOfA = interfaceType(C, typeArguments: [typeA]);
      // C<B> cOfB;
      var cOfB = interfaceType(C, typeArguments: [typeB]);
      // B b;
      // cOfB.m(b); // infer <B>
      expect(_inferCall2(cOfB.getMethod('m').type, [typeB]).toString(),
  