// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/member.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/generated/resolver.dart';
import 'package:analyzer/src/generated/testing/test_type_provider.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

import '../../../generated/elements_types_mixin.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(FunctionTypeTest);
  });
}

DynamicTypeImpl get dynamicType => DynamicTypeImpl.instance;

VoidTypeImpl get voidType => VoidTypeImpl.instance;

Element getBaseElement(Element e) {
  if (e is Member) {
    return e.baseElement;
  } else {
    return e;
  }
}

@reflectiveTest
class FunctionTypeTest with ElementsTypesMixin {
  static const bug_33294_fixed = false;
  static const bug_33301_fixed = false;
  static const bug_33302_fixed = false;

  final TypeProvider typeProvider = TestTypeProvider();

  InterfaceType get intType => typeProvider.intType;

  ClassElement get listElement => typeProvider.listElement;

  ClassElement get mapElement => typeProvider.mapElement;

  InterfaceType get objectType => typeProvider.objectType;

  void basicChecks(FunctionType f,
      {element,
      displayName: 'dynamic Function()',
      returnType,
      namedParameterTypes: isEmpty,
      normalParameterNames: isEmpty,
      normalParameterTypes: isEmpty,
      optionalParameterNames: isEmpty,
      optionalParameterTypes: isEmpty,
      parameters: isEmpty,
      typeFormals: isEmpty,
      typeArguments: isEmpty,
      typeParameters: isEmpty,
      name: isNull}) {
    // DartType properties
    expect(f.displayName, displayName, reason: 'displayName');
    expect(f.element, element, reason: 'element');
    expect(f.name, name, reason: 'name');
    // ParameterizedType properties
    expect(f.typeArguments, typeArguments, reason: 'typeArguments');
    expect(f.typeParameters, typeParameters, reason: 'typeParameters');
    // FunctionType properties
    expect(f.namedParameterTypes, namedParameterTypes,
        reason: 'namedParameterTypes');
    expect(f.normalParameterNames, normalParameterNames,
        reason: 'normalParameterNames');
    expect(f.normalParameterTypes, normalParameterTypes,
        reason: 'normalParameterTypes');
    expect(f.optionalParameterNames, optionalParameterNames,
        reason: 'optionalParameterNames');
    expect(f.optionalParameterTypes, optionalParameterTypes,
        reason: 'optionalParameterTypes');
    expect(f.parameters, parameters, reason: 'parameters');
    expect(f.returnType, returnType ?? same(dynamicType), reason: 'returnType');
    expect(f.typeFormals, typeFormals, reason: 'typeFormals');
  }

  GenericTypeAliasElementImpl genericTypeAliasElement(
    String name, {
    List<ParameterElement> parameters: const [],
    DartType returnType,
    List<TypeParameterElement> typeParameters: const [],
    List<TypeParameterElement> innerTypeParameters: const [],
  }) {
    var aliasElement = GenericTypeAliasElementImpl(name, 0);
    aliasElement.typeParameters = typeParameters;

    var functionElement = GenericFunctionTypeElementImpl.forOffset(0);
    aliasElement.function = functionElement;
    functionElement.typeParameters = innerTypeParameters;
    functionElement.parameters = parameters;
    functionElement.returnType = returnType;

    return aliasElement;
  }

  DartType listOf(DartType elementType) => listElement.instantiate(
        typeArguments: [elementType],
        nullabilitySuffix: NullabilitySuffix.star,
      );

  DartType mapOf(DartType keyType, DartType valueType) =>
      mapElement.instantiate(
        typeArguments: [keyType, valueType],
        nullabilitySuffix: NullabilitySuffix.star,
      );

  test_forInstantiatedTypedef_bothTypeParameters_noTypeArgs() {
    // typedef F<T> = Map<T, U> Function<U>();
    var t = typeParameter('T');
    var u = typeParameter('U');
    var e = genericTypeAliasElement('F',
        typeParameters: [t],
        innerTypeParameters: [u],
        returnType: mapOf(typeParameterType(t), typeParameterType(u)));
    FunctionType f = new FunctionTypeImpl.forTypedef(e);
    // Note: forTypedef returns the type `<T>() -> Map<T, U>`.
    // See https://github.com/dart-lang/sdk/issues/34657.
    basicChecks(f,
        element: same(e),
        displayName: 'F',
        name: 'F',
        typeFormals: [same(t)],
        returnType: mapOf(typeParameterType(t), typeParameterType(u)));
  }

  test_forInstantiatedTypedef_innerTypeParameter_noTypeArgs() {
    // typedef F = T F<T>();
    var t = typeParameter('T');
    var e = genericTypeAliasElement('F',
        innerTypeParameters: [t], returnType: typeParameterType(t));
    FunctionType f = new FunctionTypeImpl.forTypedef(e);
    // Note: forTypedef returns the type `() -> T`.
    // See https://github.com/dart-lang/sdk/issues/34657.
    basicChecks(f,
        element: same(e),
        displayName: 'F',
        name: 'F',
        returnType: typeParameterType(t));
  }

  test_forInstantiatedTypedef_noTypeParameters_noTypeArgs() {
    // typedef F = void Function();
    var e = genericTypeAliasElement('F');
    FunctionType f = new FunctionTypeImpl.forTypedef(e);
    // Note: forTypedef returns the type `() -> void`.
    basicChecks(f, element: same(e), displayName: 'F', name: 'F');
  }

  test_forInstantiatedTypedef_outerTypeParameters_noTypeArgs() {
    // typedef F<T> = T Function();
    var t = typeParameter('T');
    var e = genericTypeAliasElement('F',
        typeParameters: [t], returnType: typeParameterType(t));
    FunctionType f = new FunctionTypeImpl.forTypedef(e);
    // Note: forTypedef returns the type `<T>() -> T`.
    // See https://github.com/dart-lang/sdk/issues/34657.
    basicChecks(f,
        element: same(e),
        displayName: 'F',
        name: 'F',
        typeFormals: [same(t)],
        returnType: typeParameterType(t));
  }

  test_forTypedef() {
    var e = genericTypeAliasElement('F');
    basicChecks(functionTypeAliasType(e),
        element: same(e), displayName: 'F', name: 'F');
    basicChecks(e.function.type,
        element: same(e.function), displayName: 'dynamic Function()');
  }

  test_forTypedef_innerAndOuterTypeParameter() {
    // typedef F<T> = T Function<U>(U p);
    var t = typeParameter('T');
    var u = typeParameter('U');
    var p = requiredParameter('p', type: typeParameterType(u));
    var e = genericTypeAliasElement('F',
        typeParameters: [t],
        innerTypeParameters: [u],
        returnType: typeParameterType(t),
        parameters: [p]);
    basicChecks(e.type,
        element: same(e),
        displayName: 'F',
        name: 'F',
        returnType: typeParameterType(t),
        normalParameterTypes: [typeParameterType(u)],
        normalParameterNames: ['p'],
        parameters: [same(p)],
        typeFormals: [same(t)]);
    basicChecks(e.function.type,
        element: same(e.function),
        displayName: 'T Function<U>(U)',
        returnType: typeParameterType(t),
        typeArguments: [typeParameterType(t)],
        typeParameters: [same(t)],
        typeFormals: [same(u)],
        normalParameterTypes: [typeParameterType(u)],
        normalParameterNames: ['p'],
        parameters: [same(p)]);
  }

  test_forTypedef_innerAndOuterTypeParameter_instantiate() {
    // typedef F<T> = T Function<U>(U p);
    var t = typeParameter('T');
    var u = typeParameter('U');
    var p = requiredParameter('p', type: typeParameterType(u));
    var e = genericTypeAliasElement('F',
        typeParameters: [t],
        innerTypeParameters: [u],
        returnType: typeParameterType(t),
        parameters: [p]);
    var instantiated = functionTypeAliasType(e, typeArguments: [objectType]);
    basicChecks(instantiated,
        element: same(e),
        displayName: 'F<Object>',
        name: 'F',
        returnType: same(objectType),
        normalParameterTypes: [typeParameterType(u)],
        normalParameterNames: ['p'],
        parameters: [same(p)],
        typeFormals: isNotNull,
        typeArguments: [same(objectType)],
        typeParameters: [same(t)]);
    if (bug_33294_fixed) {
      expect(instantiated.typeFormals, [same(u)]);
    } else {
      expect(instantiated.typeFormals, isEmpty);
    }
  }

  test_forTypedef_innerTypeParameter() {
    // typedef F = T Function<T>();
    var t = typeParameter('T');
    var e = genericTypeAliasElement('F',
        innerTypeParameters: [t], returnType: typeParameterType(t));
    basicChecks(functionTypeAliasType(e),
        element: same(e),
        displayName: 'F',
        name: 'F',
        returnType: typeParameterType(t));
    basicChecks(e.function.type,
        element: same(e.function),
        displayName: 'T Function<T>()',
        returnType: typeParameterType(t),
        typeFormals: [same(t)]);
  }

  test_forTypedef_normalParameter() {
    var p = requiredParameter('p', type: dynamicType);
    var e = genericTypeAliasElement('F', parameters: [p]);
    basicChecks(functionTypeAliasType(e),
        element: same(e),
        displayName: 'F',
        name: 'F',
        normalParameterNames: ['p'],
        normalParameterTypes: [same(dynamicType)],
        parameters: [same(p)]);
    basicChecks(e.function.type,
        element: same(e.function),
        displayName: 'dynamic Function(dynamic)',
        normalParameterNames: ['p'],
        normalParameterTypes: [same(dynamicType)],
        parameters: [same(p)]);
  }

  test_forTypedef_recursive_via_interfaceTypes() {
    // typedef F = List<G> Function();
    // typedef G = List<F> Function();
    var f = genericTypeAliasElement('F');
    var g = genericTypeAliasElement('G');
    f.function.returnType = listOf(g.function.type);
    g.function.returnType = listOf(f.function.type);
    basicChecks(functionTypeAliasType(f),
        element: same(f), displayName: 'F', name: 'F', returnType: isNotNull);
    var fReturn = functionTypeAliasType(f).returnType;
    expect(fReturn.element, same(listElement));
    if (bug_33302_fixed) {
      expect(fReturn.displayName, 'List<G>');
    } else {
      expect(fReturn.displayName, 'List<List<...> Function()>');
    }
    var fReturnArg = (fReturn as InterfaceType).typeArguments[0];
    expect(fReturnArg.element, same(g.function));
    var fReturnArgReturn = (fReturnArg as FunctionType).returnType;
    expect(fReturnArgReturn.element, same(listElement));
    expect((fReturnArgReturn as InterfaceType).typeArguments[0],
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(f.function.type,
        element: same(f.function), displayName: isNotNull, returnType: fReturn);
    if (bug_33302_fixed) {
      expect(f.function.type.displayName, 'List<G> Function()');
    } else {
      expect(
          f.function.type.displayName, 'List<List<...> Function()> Function()');
    }
    basicChecks(functionTypeAliasType(g),
        element: same(g), displayName: 'G', name: 'G', returnType: isNotNull);
    var gReturn = functionTypeAliasType(g).returnType;
    expect(gReturn.element, same(listElement));
    if (bug_33302_fixed) {
      expect(gReturn.displayName, 'List<F>');
    } else {
      expect(gReturn.displayName, 'List<List<...> Function()>');
    }
    var gReturnArg = (gReturn as InterfaceType).typeArguments[0];
    expect(gReturnArg.element, same(f.function));
    var gReturnArgReturn = (gReturnArg as FunctionType).returnType;
    expect(gReturnArgReturn.element, same(listElement));
    expect((gReturnArgReturn as InterfaceType).typeArguments[0],
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(g.function.type,
        element: same(g.function), displayName: isNotNull, returnType: gReturn);
    if (bug_33302_fixed) {
      expect(g.function.type.displayName, 'F Function()');
    } else {
      expect(
          g.function.type.displayName, 'List<List<...> Function()> Function()');
    }
  }

  test_forTypedef_recursive_via_parameterTypes() {
    // typedef F = void Function(G g);
    // typedef G = void Function(F f);
    var f = genericTypeAliasElement('F', returnType: voidType);
    var g = genericTypeAliasElement('G', returnType: voidType);
    f.function.parameters = [requiredParameter('g', type: g.function.type)];
    g.function.parameters = [requiredParameter('f', type: f.function.type)];
    basicChecks(functionTypeAliasType(f),
        element: same(f),
        displayName: 'F',
        name: 'F',
        parameters: hasLength(1),
        normalParameterTypes: hasLength(1),
        normalParameterNames: ['g'],
        returnType: same(voidType));
    var fParamType = functionTypeAliasType(f).normalParameterTypes[0];
    expect(fParamType.element, same(g.function));
    expect((fParamType as FunctionType).normalParameterTypes[0],
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(f.function.type,
        element: same(f.function),
        displayName: isNotNull,
        parameters: hasLength(1),
        normalParameterTypes: [fParamType],
        normalParameterNames: ['g'],
        returnType: same(voidType));
    if (bug_33302_fixed) {
      expect(f.function.type.displayName, 'void Function(G)');
    } else {
      expect(f.function.type.displayName, 'void Function(void Function(...))');
    }
    basicChecks(functionTypeAliasType(g),
        element: same(g),
        displayName: 'G',
        name: 'G',
        parameters: hasLength(1),
        normalParameterTypes: hasLength(1),
        normalParameterNames: ['f'],
        returnType: same(voidType));
    var gParamType = functionTypeAliasType(g).normalParameterTypes[0];
    expect(gParamType.element, same(f.function));
    expect((gParamType as FunctionType).normalParameterTypes[0],
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(g.function.type,
        element: same(g.function),
        displayName: isNotNull,
        parameters: hasLength(1),
        normalParameterTypes: [gParamType],
        normalParameterNames: ['f'],
        returnType: same(voidType));
    if (bug_33302_fixed) {
      expect(g.function.type.displayName, 'void Function(F)');
    } else {
      expect(g.function.type.displayName, 'void Function(void Function(...))');
    }
  }

  test_forTypedef_recursive_via_returnTypes() {
    // typedef F = G Function();
    // typedef G = F Function();
    var f = genericTypeAliasElement('F');
    var g = genericTypeAliasElement('G');
    f.function.returnType = g.function.type;
    g.function.returnType = f.function.type;
    basicChecks(functionTypeAliasType(f),
        element: same(f), displayName: 'F', name: 'F', returnType: isNotNull);
    var fReturn = functionTypeAliasType(f).returnType;
    expect(fReturn.element, same(g.function));
    expect((fReturn as FunctionType).returnType,
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(f.function.type,
        element: same(f.function), displayName: isNotNull, returnType: fReturn);
    if (bug_33302_fixed) {
      expect(f.function.type.displayName, 'G Function()');
    } else {
      expect(f.function.type.displayName, '... Function() Function()');
    }
    basicChecks(functionTypeAliasType(g),
        element: same(g), displayName: 'G', name: 'G', returnType: isNotNull);
    var gReturn = functionTypeAliasType(g).returnType;
    expect(gReturn.element, same(f.function));
    expect((gReturn as FunctionType).returnType,
        new TypeMatcher<CircularFunctionTypeImpl>());
    basicChecks(g.function.type,
        element: same(g.function), displayName: isNotNull, returnType: gReturn);
    if (bug_33302_fixed) {
      expect(g.function.type.displayName, 'F Function()');
    } else {
      expect(g.function.type.displayName, '... Function() Function()');
    }
  }

  test_forTypedef_returnType() {
    var e = genericTypeAliasElement('F', returnType: objectType);
    basicChecks(functionTypeAliasType(e),
        element: same(e), displayName: 'F', name: 'F', returnType: objectType);
    basicChecks(e.function.type,
        element: same(e.function),
        displayName: 'Object Function()',
        returnType: objectType);
  }

  test_forTypedef_returnType_null() {
    var e = genericTypeAliasElement('F');
    basicChecks(functionTypeAliasType(e),
        element: same(e), displayName: 'F', name: 'F');
    basicChecks(e.function.type,
        element: same(e.function), displayName: 'dynamic Function()');
  }

  test_forTypedef_typeParameter() {
    // typedef F<T> = T Function();
    var t = typeParameter('T');
    var e = genericTypeAliasElement('F',
        typeParameters: [t], returnType: typeParameterType(t));
    basicChecks(e.type,
        element: same(e),
        displayName: 'F',
        name: 'F',
        returnType: typeParameterType(t),
        typeFormals: [same(t)]);
    basicChecks(e.function.type,
        element: same(e.function),
        displayName: 'T Function()',
        returnType: typeParameterType(t),
        typeArguments: [typeParameterType(t)],
        typeParameters: [same(t)]);
  }

  test_synthetic() {
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], []);
    basicChecks(f, element: isNull);
  }

  test_synthetic_instantiate() {
    // T Function<T>(T x)
    var t = typeParameter('T');
    var x = requiredParameter('x', type: typeParameterType(t));
    FunctionType f =
        new FunctionTypeImpl.synthetic(typeParameterType(t), [t], [x]);
    FunctionType instantiated = f.instantiate([objectType]);
    basicChecks(instantiated,
        element: isNull,
        displayName: 'Object Function(Object)',
        returnType: same(objectType),
        normalParameterNames: ['x'],
        normalParameterTypes: [same(objectType)],
        parameters: hasLength(1));
  }

  test_synthetic_instantiate_argument_length_mismatch() {
    // dynamic Function<T>()
    var t = typeParameter('T');
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [t], []);
    expect(() => f.instantiate([]), throwsA(new TypeMatcher<ArgumentError>()));
  }

  test_synthetic_instantiate_no_type_formals() {
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], []);
    expect(f.instantiate([]), same(f));
  }

  test_synthetic_instantiate_share_parameters() {
    // T Function<T>(int x)
    var t = typeParameter('T');
    var x = requiredParameter('x', type: intType);
    FunctionType f =
        new FunctionTypeImpl.synthetic(typeParameterType(t), [t], [x]);
    FunctionType instantiated = f.instantiate([objectType]);
    basicChecks(instantiated,
        element: isNull,
        displayName: 'Object Function(int)',
        returnType: same(objectType),
        normalParameterNames: ['x'],
        normalParameterTypes: [same(intType)],
        parameters: same(f.parameters));
  }

  test_synthetic_namedParameter() {
    var p = namedParameter('x', type: objectType);
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], [p]);
    basicChecks(f,
        element: isNull,
        displayName: 'dynamic Function({x: Object})',
        namedParameterTypes: {'x': same(objectType)},
        parameters: hasLength(1));
    expect(f.parameters[0].isNamed, isTrue);
    expect(f.parameters[0].name, 'x');
    expect(f.parameters[0].type, same(objectType));
  }

  test_synthetic_normalParameter() {
    var p = requiredParameter('x', type: objectType);
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], [p]);
    basicChecks(f,
        element: isNull,
        displayName: 'dynamic Function(Object)',
        normalParameterNames: ['x'],
        normalParameterTypes: [same(objectType)],
        parameters: hasLength(1));
    expect(f.parameters[0].isRequiredPositional, isTrue);
    expect(f.parameters[0].name, 'x');
    expect(f.parameters[0].type, same(objectType));
  }

  test_synthetic_optionalParameter() {
    var p = positionalParameter('x', type: objectType);
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], [p]);
    basicChecks(f,
        element: isNull,
        displayName: 'dynamic Function([Object])',
        optionalParameterNames: ['x'],
        optionalParameterTypes: [same(objectType)],
        parameters: hasLength(1));
    expect(f.parameters[0].isOptionalPositional, isTrue);
    expect(f.parameters[0].name, 'x');
    expect(f.parameters[0].type, same(objectType));
  }

  test_synthetic_returnType() {
    FunctionType f = new FunctionTypeImpl.synthetic(objectType, [], []);
    basicChecks(f,
        element: isNull,
        displayName: 'Object Function()',
        returnType: same(objectType));
  }

  test_synthetic_substitute() {
    // Map<T, U> Function<U extends T>(T x, U y)
    var t = typeParameter('T');
    var u = typeParameter('U', bound: typeParameterType(t));
    var x = requiredParameter('x', type: typeParameterType(t));
    var y = requiredParameter('y', type: typeParameterType(u));
    FunctionType f = new FunctionTypeImpl.synthetic(
        mapOf(typeParameterType(t), typeParameterType(u)), [u], [x, y]);
    FunctionType substituted =
        f.substitute2([objectType], [typeParameterType(t)]);
    var uSubstituted = substituted.typeFormals[0];
    basicChecks(substituted,
        element: isNull,
        displayName: 'Map<Object, U> Function<U extends Object>(Object, U)',
        returnType: mapOf(objectType, typeParameterType(uSubstituted)),
        typeFormals: [uSubstituted],
        normalParameterNames: ['x', 'y'],
        normalParameterTypes: [
          same(objectType),
          typeParameterType(uSubstituted)
        ],
        parameters: hasLength(2));
  }

  test_synthetic_substitute_argument_length_mismatch() {
    // dynamic Function()
    var t = typeParameter('T');
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [], []);
    expect(() => f.substitute2([], [typeParameterType(t)]),
        throwsA(new TypeMatcher<ArgumentError>()));
  }

  test_synthetic_substitute_unchanged() {
    // dynamic Function<U>(U x)
    var t = typeParameter('T');
    var u = typeParameter('U');
    var x = requiredParameter('x', type: typeParameterType(u));
    FunctionType f = new FunctionTypeImpl.synthetic(dynamicType, [u], [x]);
    FunctionType substituted =
        f.substitute2([objectType], [typeParameterType(t)]);
    expect(substituted, same(f));
  }

  test_synthetic_typeFormals() {
    var t = typeParameter('T');
    FunctionType f =
        new FunctionTypeImpl.synthetic(typeParameterType(t), [t], []);
    basicChecks(f,
        element: isNull,
        displayName: 'T Function<T>()',
        returnType: typeParameterType(t),
        typeFormals: [same(t)]);
  }

  test_unnamedConstructor() {
    var e = new MockFunctionTypedElement();
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f, element: same(e));
  }

  test_unnamedConstructor_instantiate_argument_length_mismatch() {
    var t = typeParameter('T');
    var e = new MockFunctionTypedElement(typeParameters: [t]);
    FunctionType f = new FunctionTypeImpl(e);
    expect(() => f.instantiate([]), throwsA(new TypeMatcher<ArgumentError>()));
  }

  test_unnamedConstructor_instantiate_noTypeParameters() {
    var e = new MockFunctionTypedElement();
    FunctionType f = new FunctionTypeImpl(e);
    expect(f.instantiate([]), same(f));
  }

  test_unnamedConstructor_instantiate_parameterType_simple() {
    var t = typeParameter('T');
    var p = requiredParameter('x', type: typeParameterType(t));
    var e = new MockFunctionTypedElement(typeParameters: [t], parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    var instantiated = f.instantiate([objectType]);
    basicChecks(instantiated,
        element: same(e),
        displayName: 'dynamic Function(Object)',
        typeArguments: hasLength(1),
        typeParameters: [same(t)],
        normalParameterNames: ['x'],
        normalParameterTypes: [same(objectType)],
        parameters: hasLength(1));
    expect(instantiated.typeArguments[0], same(objectType));
    expect(instantiated.parameters[0].name, 'x');
    expect(instantiated.parameters[0].type, same(objectType));
  }

  test_unnamedConstructor_instantiate_returnType_simple() {
    var t = typeParameter('T');
    var e = new MockFunctionTypedElement(
        typeParameters: [t], returnType: typeParameterType(t));
    FunctionType f = new FunctionTypeImpl(e);
    var instantiated = f.instantiate([objectType]);
    basicChecks(instantiated,
        element: same(e),
        displayName: 'Object Function()',
        typeArguments: hasLength(1),
        typeParameters: [same(t)],
        returnType: same(objectType));
    expect(instantiated.typeArguments[0], same(objectType));
  }

  test_unnamedConstructor_namedParameter() {
    var p = namedParameter('x', type: dynamicType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function({x: dynamic})',
        namedParameterTypes: {'x': same(dynamicType)},
        parameters: [same(p)]);
  }

  test_unnamedConstructor_namedParameter_object() {
    var p = namedParameter('x', type: objectType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function({x: Object})',
        namedParameterTypes: {'x': same(objectType)},
        parameters: [same(p)]);
  }

  test_unnamedConstructor_nonTypedef_noTypeArguments() {
    var e = new MockFunctionTypedElement();
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f, element: same(e));
  }

  test_unnamedConstructor_nonTypedef_withTypeArguments() {
    var t = typeParameter('T');
    var e = method('e', typeParameterType(t));
    class_(name: 'C', typeParameters: [t], methods: [e]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        typeArguments: [typeParameterType(t)],
        typeParameters: [same(t)],
        displayName: 'T Function()',
        returnType: typeParameterType(t));
  }

  test_unnamedConstructor_normalParameter() {
    var p = requiredParameter('x', type: dynamicType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function(dynamic)',
        normalParameterNames: ['x'],
        normalParameterTypes: [same(dynamicType)],
        parameters: [same(p)]);
  }

  test_unnamedConstructor_normalParameter_object() {
    var p = requiredParameter('x', type: objectType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function(Object)',
        normalParameterNames: ['x'],
        normalParameterTypes: [same(objectType)],
        parameters: [same(p)]);
  }

  test_unnamedConstructor_optionalParameter() {
    var p = positionalParameter('x', type: dynamicType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function([dynamic])',
        optionalParameterNames: ['x'],
        optionalParameterTypes: [same(dynamicType)],
        parameters: [same(p)]);
  }

  test_unnamedConstructor_optionalParameter_object() {
    var p = positionalParameter('x', type: objectType);
    var e = new MockFunctionTypedElement(parameters: [p]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function([Object])',
        optionalParameterNames: ['x'],
        optionalParameterTypes: [same(objectType)],
        parameters: [same(p)]);
  }

  test_unnamedConstructor_returnType() {
    var e = new MockFunctionTypedElement(returnType: objectType);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        returnType: same(objectType),
        displayName: 'Object Function()');
  }

  test_unnamedConstructor_returnType_null() {
    var e = new MockFunctionTypedElement.withNullReturn();
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        returnType: same(dynamicType),
        displayName: 'dynamic Function()');
  }

  test_unnamedConstructor_staticMethod_ignores_enclosing_type_params() {
    var t = typeParameter('T');
    var e = method('e', dynamicType, isStatic: true);
    class_(name: 'C', typeParameters: [t], methods: [e]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f, element: same(e));
  }

  test_unnamedConstructor_substitute_argument_length_mismatch() {
    // abstract class C<T> {
    //   dynamic f();
    // }
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var e = new MockFunctionTypedElement(enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    expect(() => f.substitute2([], [typeParameterType(t)]),
        throwsA(new TypeMatcher<ArgumentError>()));
  }

  test_unnamedConstructor_substitute_bound_recursive() {
    // abstract class C<T> {
    //   Map<S, V> f<S extends T, T extends U, V extends T>();
    // }
    var s = typeParameter('S');
    var t = typeParameter('T');
    var u = typeParameter('U');
    var v = typeParameter('V');
    s.bound = typeParameterType(t);
    t.bound = typeParameterType(u);
    v.bound = typeParameterType(t);
    var c = class_(name: 'C', typeParameters: [u]);
    var e = new MockFunctionTypedElement(
        returnType: mapOf(typeParameterType(s), typeParameterType(v)),
        typeParameters: [s, t, v],
        enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    var substituted = f.substitute2([objectType], [typeParameterType(u)]);
    basicChecks(substituted,
        element: same(e),
        displayName: isNotNull,
        returnType: isNotNull,
        typeFormals: hasLength(3),
        typeParameters: [same(u)],
        typeArguments: [same(objectType)]);
    expect(substituted.displayName,
        'Map<S, V> Function<S extends T,T extends Object,V extends T>()');
    var s2 = substituted.typeFormals[0];
    var t2 = substituted.typeFormals[1];
    var v2 = substituted.typeFormals[2];
    expect(s2.name, 'S');
    expect(t2.name, 'T');
    expect(v2.name, 'V');
    expect(s2.bound, typeParameterType(t2));
    expect(t2.bound, same(objectType));
    expect(v2.bound, typeParameterType(t2));
    if (bug_33301_fixed) {
      expect(substituted.returnType,
          mapOf(typeParameterType(s2), typeParameterType(v2)));
    } else {
      expect(substituted.returnType,
          mapOf(typeParameterType(s), typeParameterType(v)));
    }
  }

  test_unnamedConstructor_substitute_bound_recursive_parameter() {
    // abstract class C<T> {
    //   void f<S extends T, T extends U, V extends T>(S x, V y);
    // }
    var s = typeParameter('S');
    var t = typeParameter('T');
    var u = typeParameter('U');
    var v = typeParameter('V');
    s.bound = typeParameterType(t);
    t.bound = typeParameterType(u);
    v.bound = typeParameterType(t);
    var c = class_(name: 'C', typeParameters: [u]);
    var x = requiredParameter('x', type: typeParameterType(s));
    var y = requiredParameter('y', type: typeParameterType(v));
    var e = new MockFunctionTypedElement(
        returnType: voidType,
        typeParameters: [s, t, v],
        enclosingElement: c,
        parameters: [x, y]);
    FunctionType f = new FunctionTypeImpl(e);
    var substituted = f.substitute2([objectType], [typeParameterType(u)]);
    basicChecks(substituted,
        element: same(e),
        displayName: isNotNull,
        returnType: same(voidType),
        normalParameterNames: ['x', 'y'],
        normalParameterTypes: hasLength(2),
        parameters: hasLength(2),
        typeFormals: hasLength(3),
        typeParameters: [same(u)],
        typeArguments: [same(objectType)]);
    expect(substituted.displayName,
        'void Function<S extends T,T extends Object,V extends T>(S, V)');
    var s2 = substituted.typeFormals[0];
    var t2 = substituted.typeFormals[1];
    var v2 = substituted.typeFormals[2];
    expect(s2.name, 'S');
    expect(t2.name, 'T');
    expect(v2.name, 'V');
    expect(s2.bound, typeParameterType(t2));
    expect(t2.bound, same(objectType));
    expect(v2.bound, typeParameterType(t2));
    if (bug_33301_fixed) {
      expect(substituted.normalParameterTypes,
          [same(typeParameterType(s2)), same(typeParameterType(v2))]);
    } else {
      expect(substituted.normalParameterTypes,
          [typeParameterType(s), typeParameterType(v)]);
    }
  }

  test_unnamedConstructor_substitute_bound_simple() {
    // abstract class C<T> {
    //   U f<U extends T>();
    // }
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var u = typeParameter('U', bound: typeParameterType(t));
    var e = new MockFunctionTypedElement(
        typeParameters: [u],
        returnType: typeParameterType(u),
        enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    var substituted = f.substitute2([objectType], [typeParameterType(t)]);
    basicChecks(substituted,
        element: same(e),
        displayName: 'U Function<U extends Object>()',
        typeArguments: [same(objectType)],
        typeParameters: [same(t)],
        returnType: isNotNull,
        typeFormals: hasLength(1));
    expect(substituted.typeFormals[0].name, 'U');
    expect(substituted.typeFormals[0].bound, same(objectType));
    expect((substituted.returnType as TypeParameterTypeImpl).element,
        same(getBaseElement(substituted.typeFormals[0])));
  }

  test_unnamedConstructor_substitute_noop() {
    var t = typeParameter('T');
    var e = new MockFunctionTypedElement(returnType: typeParameterType(t));
    FunctionType f = new FunctionTypeImpl(e);
    var substituted =
        f.substitute2([typeParameterType(t)], [typeParameterType(t)]);
    basicChecks(substituted,
        element: same(e),
        displayName: 'T Function()',
        returnType: typeParameterType(t));
    // TODO(paulberry): test substitute length mismatch
  }

  test_unnamedConstructor_substitute_parameterType_simple() {
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var p = requiredParameter('x', type: typeParameterType(t));
    var e = new MockFunctionTypedElement(parameters: [p], enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    var substituted = f.substitute2([objectType], [typeParameterType(t)]);
    basicChecks(substituted,
        element: same(e),
        displayName: 'dynamic Function(Object)',
        normalParameterNames: ['x'],
        normalParameterTypes: [same(objectType)],
        parameters: hasLength(1),
        typeArguments: [same(objectType)],
        typeParameters: [same(t)]);
    expect(substituted.parameters[0].name, 'x');
    expect(substituted.parameters[0].type, same(objectType));
  }

  test_unnamedConstructor_substitute_returnType_simple() {
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var e = new MockFunctionTypedElement(
        returnType: typeParameterType(t), enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    var substituted = f.substitute2([objectType], [typeParameterType(t)]);
    basicChecks(substituted,
        element: same(e),
        displayName: 'Object Function()',
        returnType: same(objectType),
        typeArguments: [same(objectType)],
        typeParameters: [same(t)]);
  }

  test_unnamedConstructor_typeParameter() {
    var t = typeParameter('T');
    var e = new MockFunctionTypedElement(typeParameters: [t]);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'dynamic Function<T>()',
        typeFormals: [same(t)]);
    // TODO(paulberry): test pruning of bounds
  }

  test_unnamedConstructor_typeParameter_with_bound() {
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var u = typeParameter('U', bound: typeParameterType(t));
    var e = new MockFunctionTypedElement(
        typeParameters: [u],
        returnType: typeParameterType(u),
        enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'U Function<U extends T>()',
        typeArguments: [typeParameterType(t)],
        typeParameters: [same(t)],
        returnType: typeParameterType(u),
        typeFormals: hasLength(1));
    expect(f.typeFormals[0].name, 'U');
    expect(f.typeFormals[0].bound, typeParameterType(t));
  }

  test_unnamedConstructor_with_enclosing_type_parameters() {
    // Test a weird behavior: substitutions are recorded in typeArguments and
    // typeParameters.
    var t = typeParameter('T');
    var c = class_(name: 'C', typeParameters: [t]);
    var e = new MockFunctionTypedElement(
        returnType: typeParameterType(t), enclosingElement: c);
    FunctionType f = new FunctionTypeImpl(e);
    basicChecks(f,
        element: same(e),
        displayName: 'T Function()',
        returnType: typeParameterType(t),
        typeArguments: [typeParameterType(t)],
        typeParameters: [same(t)]);
  }
}

class MockCompilationUnitElement implements CompilationUnitElement {
  const MockCompilationUnitElement();

  @override
  get enclosingElement => const MockLibraryElement();

  noSuchMethod(Invocation invocation) {
    return super.noSuchMethod(invocation);
  }
}

class MockFunctionTypedElement implements FunctionTypedElement {
  @override
  final List<ParameterElement> parameters;

  @override
  final DartType returnType;

  @override
  final List<TypeParameterElement> typeParameters;

  @override
  final Element enclosingElement;

  MockFunctionTypedElement(
      {this.parameters: const [],
      DartType returnType,
      this.typeParameters: const [],
      this.enclosingElement: const MockCompilationUnitElement()})
      : returnType = returnType ?? dynamicType;

  MockFunctionTypedElement.withNullReturn(
      {this.parameters: const [],
      this.typeParameters: const [],
      this.enclosingElement: const MockCompilationUnitElement()})
      : returnType = null;

  noSuchMethod(Invocation invocation) {
    return super.noSuchMethod(invocation);
  }
}

class MockLibraryElement implements LibraryElement {
  const MockLibraryElement();

  @override
  get enclosingElement => null;

  noSuchMethod(Invocation invocation) {
    return super.noSuchMethod(invocation);
  }
}