| // Copyright (c) 2019, 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/analysis/features.dart'; |
| 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/type.dart'; |
| import 'package:analyzer/src/dart/element/type_visitor.dart'; |
| import 'package:analyzer/src/dart/resolver/variance.dart'; |
| import 'package:test/test.dart'; |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| |
| import '../../../generated/type_system_test.dart'; |
| |
| main() { |
| defineReflectiveSuite(() { |
| defineReflectiveTests(SubtypeTest); |
| defineReflectiveTests(NonNullableSubtypingCompoundTest); |
| defineReflectiveTests(SubtypingCompoundTest); |
| }); |
| } |
| |
| @reflectiveTest |
| class NonNullableSubtypingCompoundTest extends _SubtypingCompoundTestBase { |
| @override |
| FeatureSet get testFeatureSet { |
| return FeatureSet.forTesting( |
| additionalFeatures: [Feature.non_nullable], |
| ); |
| } |
| |
| test_dynamic() { |
| var equivalents = <DartType>[ |
| voidNone, |
| objectQuestion, |
| objectStar, |
| ]; |
| |
| var subtypes = <DartType>[ |
| neverNone, |
| nullNone, |
| objectNone, |
| ]; |
| |
| _checkGroups( |
| dynamicNone, |
| equivalents: equivalents, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_futureOr_topTypes() { |
| var futureOrObject = futureOrNone(objectNone); |
| var futureOrObjectStar = futureOrNone(objectStar); |
| var futureOrObjectQuestion = futureOrNone(objectQuestion); |
| |
| var futureOrStarObject = futureOrStar(objectNone); |
| var futureOrStarObjectStar = futureOrStar(objectStar); |
| var futureOrStarObjectQuestion = futureOrStar(objectQuestion); |
| |
| var futureOrQuestionObject = futureOrQuestion(objectNone); |
| var futureOrQuestionObjectStar = futureOrQuestion(objectStar); |
| var futureOrQuestionObjectQuestion = futureOrQuestion(objectQuestion); |
| |
| //FutureOr<Object> <: FutureOr*<Object?> |
| _checkGroups( |
| futureOrObject, |
| equivalents: [ |
| objectStar, |
| futureOrObjectStar, |
| futureOrStarObject, |
| futureOrStarObjectStar, |
| objectNone, |
| ], |
| subtypes: [], |
| supertypes: [ |
| objectQuestion, |
| futureOrQuestionObject, |
| futureOrObjectQuestion, |
| futureOrQuestionObject, |
| futureOrQuestionObjectStar, |
| futureOrStarObjectQuestion, |
| futureOrQuestionObjectQuestion, |
| ], |
| ); |
| } |
| |
| test_intNone() { |
| var equivalents = <DartType>[ |
| intNone, |
| intStar, |
| ]; |
| |
| var subtypes = <DartType>[ |
| neverNone, |
| ]; |
| |
| var supertypes = <DartType>[ |
| intQuestion, |
| objectNone, |
| objectQuestion, |
| ]; |
| |
| var unrelated = <DartType>[ |
| doubleNone, |
| nullNone, |
| nullStar, |
| nullQuestion, |
| neverQuestion, |
| ]; |
| |
| _checkGroups( |
| intNone, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_intQuestion() { |
| var equivalents = <DartType>[ |
| intQuestion, |
| intStar, |
| ]; |
| |
| var subtypes = <DartType>[ |
| intNone, |
| nullNone, |
| nullQuestion, |
| nullStar, |
| neverNone, |
| neverQuestion, |
| neverStar, |
| ]; |
| |
| var supertypes = <DartType>[ |
| numQuestion, |
| numStar, |
| objectQuestion, |
| objectStar, |
| ]; |
| |
| var unrelated = <DartType>[ |
| doubleNone, |
| numNone, |
| objectNone, |
| ]; |
| |
| _checkGroups( |
| intQuestion, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_intStar() { |
| var equivalents = <DartType>[ |
| intNone, |
| intQuestion, |
| intStar, |
| ]; |
| |
| var subtypes = <DartType>[ |
| nullNone, |
| nullStar, |
| nullQuestion, |
| neverNone, |
| neverStar, |
| neverQuestion, |
| ]; |
| |
| var supertypes = <DartType>[ |
| numNone, |
| numQuestion, |
| numStar, |
| objectNone, |
| objectQuestion, |
| ]; |
| |
| var unrelated = <DartType>[ |
| doubleStar, |
| ]; |
| |
| _checkGroups( |
| intStar, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_null() { |
| var equivalents = <DartType>[ |
| nullNone, |
| nullQuestion, |
| nullStar, |
| neverQuestion, |
| ]; |
| |
| var supertypes = <DartType>[ |
| intQuestion, |
| intStar, |
| objectQuestion, |
| objectStar, |
| dynamicNone, |
| voidNone, |
| ]; |
| |
| var subtypes = <DartType>[ |
| neverNone, |
| ]; |
| |
| var unrelated = <DartType>[ |
| doubleNone, |
| intNone, |
| numNone, |
| objectNone, |
| ]; |
| |
| for (final formOfNull in equivalents) { |
| _checkGroups( |
| formOfNull, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| } |
| |
| test_object() { |
| var equivalents = <DartType>[ |
| objectStar, |
| ]; |
| |
| var supertypes = <DartType>[ |
| objectQuestion, |
| dynamicType, |
| voidNone, |
| ]; |
| |
| var subtypes = <DartType>[ |
| neverNone, |
| ]; |
| |
| var unrelated = <DartType>[ |
| doubleQuestion, |
| numQuestion, |
| intQuestion, |
| nullNone, |
| ]; |
| |
| _checkGroups( |
| objectNone, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| } |
| |
| @reflectiveTest |
| class SubtypeTest extends _SubtypingTestBase { |
| final Map<String, DartType> _types = {}; |
| |
| void assertExpectedString(TypeImpl type, String expectedString) { |
| if (expectedString != null) { |
| var typeStr = _typeStr(type); |
| |
| typeStr += _typeParametersStr(type); |
| |
| expect(typeStr, expectedString); |
| } |
| } |
| |
| void isNotSubtype( |
| DartType T0, |
| DartType T1, { |
| String strT0, |
| String strT1, |
| }) { |
| assertExpectedString(T0, strT0); |
| assertExpectedString(T1, strT1); |
| expect(typeSystem.isSubtypeOf2(T0, T1), isFalse); |
| } |
| |
| void isNotSubtype2( |
| String strT0, |
| String strT1, |
| ) { |
| var T0 = _getTypeByStr(strT0); |
| var T1 = _getTypeByStr(strT1); |
| expect(typeSystem.isSubtypeOf2(T0, T1), isFalse); |
| } |
| |
| void isNotSubtype3({ |
| String strT0, |
| String strT1, |
| }) { |
| isNotSubtype2(strT0, strT1); |
| } |
| |
| void isSubtype( |
| DartType T0, |
| DartType T1, { |
| String strT0, |
| String strT1, |
| }) { |
| assertExpectedString(T0, strT0); |
| assertExpectedString(T1, strT1); |
| expect(typeSystem.isSubtypeOf2(T0, T1), isTrue); |
| } |
| |
| void isSubtype2( |
| String strT0, |
| String strT1, |
| ) { |
| var T0 = _getTypeByStr(strT0); |
| var T1 = _getTypeByStr(strT1); |
| expect(typeSystem.isSubtypeOf2(T0, T1), isTrue); |
| } |
| |
| @override |
| void setUp() { |
| super.setUp(); |
| _defineTypes(); |
| } |
| |
| test_functionType_01() { |
| var E0 = typeParameter('E0'); |
| var E1 = typeParameter('E1', bound: numStar); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: numStar), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0 Function<E0>(E0, num*)*', |
| strT1: 'E1* Function<E1 extends num*>(E1*, E1*)*', |
| ); |
| } |
| |
| test_functionType_02() { |
| var E0 = typeParameter('E0', bound: numStar); |
| var E1 = typeParameter('E1', bound: intStar); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function<E0 extends num*>(E0*)*', |
| strT1: 'int* Function<E1 extends int*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_03() { |
| var E0 = typeParameter('E0', bound: numStar); |
| var E1 = typeParameter('E1', bound: intStar); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0* Function<E0 extends num*>(E0*)*', |
| strT1: 'E1* Function<E1 extends int*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_04() { |
| var E0 = typeParameter('E0', bound: numStar); |
| var E1 = typeParameter('E1', bound: intStar); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0* Function<E0 extends num*>(int*)*', |
| strT1: 'E1* Function<E1 extends int*>(int*)*', |
| ); |
| } |
| |
| test_functionType_05() { |
| var E0 = typeParameter('E0', bound: numStar); |
| var E1 = typeParameter('E1', bound: numStar); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'E0* Function<E0 extends num*>(E0*)*', |
| strT1: 'num* Function<E1 extends num*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_06() { |
| var E0 = typeParameter('E0', bound: intStar); |
| var E1 = typeParameter('E1', bound: intStar); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'E0* Function<E0 extends int*>(E0*)*', |
| strT1: 'num* Function<E1 extends int*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_07() { |
| var E0 = typeParameter('E0', bound: intStar); |
| var E1 = typeParameter('E1', bound: intStar); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'E0* Function<E0 extends int*>(E0*)*', |
| strT1: 'int* Function<E1 extends int*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_08() { |
| var E0 = typeParameter('E0'); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function<E0>(int*)*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_09() { |
| var E0 = typeParameter('E0'); |
| var F0 = typeParameter('F0'); |
| var E1 = typeParameter('E1'); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0, F0], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function<E0, F0>(int*)*', |
| strT1: 'int* Function<E1>(int*)*', |
| ); |
| } |
| |
| test_functionType_10() { |
| var E0 = typeParameter('E0'); |
| E0.bound = listStar( |
| typeParameterTypeStar(E0), |
| ); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0* Function<E0 extends List<E0*>*>(E0*)*', |
| strT1: 'E1* Function<E1 extends List<E1*>*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_11() { |
| var E0 = typeParameter('E0'); |
| E0.bound = iterableStar( |
| typeParameterTypeStar(E0), |
| ); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E0)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0* Function<E0 extends Iterable<E0*>*>(E0*)*', |
| strT1: 'E1* Function<E1 extends List<E1*>*>(E1*)*', |
| ); |
| } |
| |
| test_functionType_12() { |
| var E0 = typeParameter('E0'); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: listStar(objectStar)), |
| ], |
| returnType: typeParameterTypeStar(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'E0* Function<E0>(E0, List<Object*>*)*', |
| strT1: 'E1* Function<E1 extends List<E1*>*>(E1*, E1*)*', |
| ); |
| } |
| |
| test_functionType_13() { |
| var E0 = typeParameter('E0'); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: listStar(objectStar)), |
| ], |
| returnType: listStar( |
| typeParameterTypeNone(E0), |
| ), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'List<E0>* Function<E0>(E0, List<Object*>*)*', |
| strT1: 'E1* Function<E1 extends List<E1*>*>(E1*, E1*)*', |
| ); |
| } |
| |
| test_functionType_14() { |
| var E0 = typeParameter('E0'); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: listStar(objectStar)), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: typeParameterTypeStar(E1), |
| ), |
| strT0: 'int* Function<E0>(E0, List<Object*>*)*', |
| strT1: 'E1* Function<E1 extends List<E1*>*>(E1*, E1*)*', |
| ); |
| } |
| |
| test_functionType_15() { |
| var E0 = typeParameter('E0'); |
| |
| var E1 = typeParameter('E1'); |
| E1.bound = listStar( |
| typeParameterTypeStar(E1), |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: listStar(objectStar)), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| requiredParameter(type: typeParameterTypeStar(E1)), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'E0 Function<E0>(E0, List<Object*>*)*', |
| strT1: 'void Function<E1 extends List<E1*>*>(E1*, E1*)*', |
| ); |
| } |
| |
| test_functionType_16() { |
| isSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionStar, |
| strT0: 'int* Function()*', |
| strT1: 'Function*', |
| ); |
| } |
| |
| test_functionType_17() { |
| isNotSubtype( |
| functionStar, |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| strT0: 'Function*', |
| strT1: 'int* Function()*', |
| ); |
| } |
| |
| test_functionType_18() { |
| isSubtype( |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| strT0: 'dynamic Function()*', |
| strT1: 'dynamic Function()*', |
| ); |
| } |
| |
| test_functionType_19() { |
| isSubtype( |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'dynamic Function()*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_functionType_20() { |
| isSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| strT0: 'void Function()*', |
| strT1: 'dynamic Function()*', |
| ); |
| } |
| |
| test_functionType_21() { |
| isSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_functionType_22() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| strT0: 'void Function()*', |
| strT1: 'int* Function()*', |
| ); |
| } |
| |
| test_functionType_23() { |
| isSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'void Function()*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_functionType_24() { |
| isSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'int* Function()*', |
| ); |
| } |
| |
| test_functionType_25() { |
| isSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| returnType: objectStar, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'Object* Function()*', |
| ); |
| } |
| |
| test_functionType_26() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| returnType: doubleStar, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'double* Function()*', |
| ); |
| } |
| |
| test_functionType_27() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_28() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'void Function()*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_29() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function()*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_30() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function(int*)*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_31() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: objectStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: objectStar, |
| ), |
| strT0: 'int* Function(Object*)*', |
| strT1: 'Object* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_32() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: doubleStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function(int*)*', |
| strT1: 'int* Function(double*)*', |
| ); |
| } |
| |
| test_functionType_33() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function()*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_34() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function(int*)*', |
| strT1: 'int* Function(int*, int*)*', |
| ); |
| } |
| |
| test_functionType_35() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'int* Function(int*, int*)*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_36() { |
| var f = functionTypeStar( |
| parameters: [ |
| requiredParameter( |
| type: functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| ], |
| returnType: voidNone, |
| ); |
| var g = functionTypeStar( |
| parameters: [ |
| requiredParameter( |
| type: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| ], |
| returnType: voidNone, |
| ); |
| |
| isNotSubtype( |
| f, |
| g, |
| strT0: 'void Function(void Function()*)*', |
| strT1: 'void Function(void Function(int*)*)*', |
| ); |
| |
| isNotSubtype( |
| g, |
| f, |
| strT0: 'void Function(void Function(int*)*)*', |
| strT1: 'void Function(void Function()*)*', |
| ); |
| } |
| |
| test_functionType_37() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_functionType_38() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_39() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function(int*)*', |
| strT1: 'void Function([int*])*', |
| ); |
| } |
| |
| test_functionType_40() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function([int*])*', |
| ); |
| } |
| |
| test_functionType_41() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: objectStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([Object*])*', |
| strT1: 'void Function([int*])*', |
| ); |
| } |
| |
| test_functionType_42() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: objectStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function([Object*])*', |
| ); |
| } |
| |
| test_functionType_43() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function(int*, [int*])*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_44() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function(int*, [int*])*', |
| strT1: 'void Function(int*, [int*])*', |
| ); |
| } |
| |
| test_functionType_45() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*, int*])*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_46() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*, int*])*', |
| strT1: 'void Function(int*, [int*])*', |
| ); |
| } |
| |
| test_functionType_47() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*, int*])*', |
| strT1: 'void Function(int*, [int*, int*])*', |
| ); |
| } |
| |
| test_functionType_48() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*, int*, int*])*', |
| strT1: 'void Function(int*, [int*, int*])*', |
| ); |
| } |
| |
| test_functionType_49() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: doubleStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function(double*)*', |
| ); |
| } |
| |
| test_functionType_50() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*])*', |
| strT1: 'void Function([int*, int*])*', |
| ); |
| } |
| |
| test_functionType_51() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([int*, int*])*', |
| strT1: 'void Function([int*])*', |
| ); |
| } |
| |
| test_functionType_52() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: objectStar), |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| positionalParameter(type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function([Object*, int*])*', |
| strT1: 'void Function([int*])*', |
| ); |
| } |
| |
| test_functionType_53() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_functionType_54() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function(int*)*', |
| ); |
| } |
| |
| test_functionType_55() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function(int*)*', |
| strT1: 'void Function({int* a})*', |
| ); |
| } |
| |
| test_functionType_56() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({int* a})*', |
| ); |
| } |
| |
| test_functionType_57() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'b', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({int* b})*', |
| ); |
| } |
| |
| test_functionType_58() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: objectStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({Object* a})*', |
| strT1: 'void Function({int* a})*', |
| ); |
| } |
| |
| test_functionType_59() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: objectStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({Object* a})*', |
| ); |
| } |
| |
| test_functionType_60() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function(int*, {int* a})*', |
| strT1: 'void Function(int*, {int* a})*', |
| ); |
| } |
| |
| test_functionType_61() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: doubleStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({double* a})*', |
| ); |
| } |
| |
| test_functionType_62() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'b', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({int* a, int* b})*', |
| ); |
| } |
| |
| test_functionType_63() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'b', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a, int* b})*', |
| strT1: 'void Function({int* a})*', |
| ); |
| } |
| |
| test_functionType_64() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'b', type: intStar), |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a, int* b, int* c})*', |
| strT1: 'void Function({int* a, int* c})*', |
| ); |
| } |
| |
| test_functionType_66() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'b', type: intStar), |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'b', type: intStar), |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a, int* b, int* c})*', |
| strT1: 'void Function({int* b, int* c})*', |
| ); |
| } |
| |
| test_functionType_68() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| namedParameter(name: 'b', type: intStar), |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'c', type: intStar), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({int* a, int* b, int* c})*', |
| strT1: 'void Function({int* c})*', |
| ); |
| } |
| |
| test_functionType_70() { |
| isSubtype( |
| functionTypeNone( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| objectNone, |
| strT0: 'num* Function(int*)', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_functionType_71() { |
| isSubtype( |
| functionTypeStar( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| objectNone, |
| strT0: 'num* Function(int*)*', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_functionType_72() { |
| isNotSubtype( |
| functionTypeQuestion( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| objectNone, |
| strT0: 'num* Function(int*)?', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_functionType_73() { |
| var E0 = typeParameter('E0', bound: objectNone); |
| var E1 = typeParameter('E1', bound: futureOrNone(objectNone)); |
| |
| isSubtype( |
| functionTypeNone( |
| typeFormals: [E0], |
| returnType: voidNone, |
| ), |
| functionTypeNone( |
| typeFormals: [E1], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function<E0 extends Object>()', |
| strT1: 'void Function<E1 extends FutureOr<Object>>()', |
| ); |
| } |
| |
| test_functionType_generic_nested() { |
| var E0 = typeParameter('E0'); |
| var F0 = typeParameter('F0'); |
| var E1 = typeParameter('E1'); |
| var F1 = typeParameter('F1'); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| ), |
| functionTypeStar( |
| typeFormals: [F1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F1)), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F1)), |
| ], |
| returnType: typeParameterTypeNone(F1), |
| ), |
| ), |
| strT0: 'E0 Function(E0)* Function<E0>(E0)*', |
| strT1: 'F1 Function(F1)* Function<F1>(F1)*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter( |
| type: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| ), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| requiredParameter( |
| type: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| ), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| strT0: 'E0 Function<E0>(E0, E0 Function(int*, E0)*)*', |
| strT1: 'E1 Function<E1>(E1, E1 Function(num*, E1)*)*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0, F0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F0)), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| ], |
| returnType: functionTypeStar( |
| typeFormals: [F1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F1)), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| ), |
| strT0: 'E0 Function(F0)* Function<E0, F0>(E0)*', |
| strT1: 'E1 Function<F1>(F1)* Function<E1>(E1)*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0, F0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F0)), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| ), |
| functionTypeStar( |
| typeFormals: [F1, E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(F1)), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| ), |
| strT0: 'E0 Function(F0)* Function<E0, F0>(E0)*', |
| strT1: 'E1 Function(F1)* Function<F1, E1>(E1)*', |
| ); |
| } |
| |
| test_functionType_generic_required() { |
| var E0 = typeParameter('E'); |
| var E1 = typeParameter('E'); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function<E>(E)*', |
| strT1: 'num* Function<E>(E)*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| strT0: 'E Function<E>(num*)*', |
| strT1: 'E Function<E>(int*)*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: numStar), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| requiredParameter(type: intStar), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| strT0: 'E Function<E>(E, num*)*', |
| strT1: 'E Function<E>(E, int*)*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| typeFormals: [E0], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E0)), |
| requiredParameter(type: numStar), |
| ], |
| returnType: typeParameterTypeNone(E0), |
| ), |
| functionTypeStar( |
| typeFormals: [E1], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| requiredParameter(type: typeParameterTypeNone(E1)), |
| ], |
| returnType: typeParameterTypeNone(E1), |
| ), |
| strT0: 'E Function<E>(E, num*)*', |
| strT1: 'E Function<E>(E, E)*', |
| ); |
| } |
| |
| test_functionType_notGeneric_functionReturnType() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| ), |
| strT0: 'num* Function(num*)* Function(num*)*', |
| strT1: 'num* Function(int*)* Function(num*)*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| ), |
| strT0: 'int* Function(int*)* Function(int*)*', |
| strT1: 'num* Function(num*)* Function(num*)*', |
| ); |
| } |
| |
| test_functionType_notGeneric_named() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'num* Function({num* x})*', |
| strT1: 'num* Function({int* x})*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| namedParameter(name: 'x', type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| namedParameter(name: 'x', type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'num* Function(num*, {num* x})*', |
| strT1: 'num* Function(int*, {int* x})*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: numStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function({num* x})*', |
| strT1: 'num* Function({num* x})*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| namedParameter(name: 'x', type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function({int* x})*', |
| strT1: 'num* Function({num* x})*', |
| ); |
| } |
| |
| test_functionType_notGeneric_required() { |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'num* Function(num*)*', |
| strT1: 'num* Function(int*)*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function(num*)*', |
| strT1: 'num* Function(num*)*', |
| ); |
| |
| isSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function(num*)*', |
| strT1: 'num* Function(int*)*', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: numStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'int* Function(int*)*', |
| strT1: 'num* Function(num*)*', |
| ); |
| |
| isSubtype( |
| nullQuestion, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: numStar, |
| ), |
| strT0: 'Null?', |
| strT1: 'num* Function(int*)*', |
| ); |
| } |
| |
| test_functionType_requiredNamedParameter_01() { |
| var F0 = functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedRequiredParameter(name: 'a', type: intNone), |
| ], |
| ); |
| |
| var F1 = functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedParameter(name: 'a', type: intNone), |
| ], |
| ); |
| |
| isSubtype( |
| F1, |
| F0, |
| strT0: 'void Function({int a})', |
| strT1: 'void Function({required int a})', |
| ); |
| |
| isNotSubtype( |
| F0, |
| F1, |
| strT0: 'void Function({required int a})', |
| strT1: 'void Function({int a})', |
| ); |
| } |
| |
| test_functionType_requiredNamedParameter_02() { |
| isNotSubtype( |
| functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedRequiredParameter(name: 'a', type: intNone), |
| ], |
| ), |
| functionTypeNone( |
| returnType: voidNone, |
| ), |
| strT0: 'void Function({required int a})', |
| strT1: 'void Function()', |
| ); |
| |
| isNotSubtype( |
| functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedRequiredParameter(name: 'a', type: intNone), |
| namedParameter(name: 'b', type: intNone), |
| ], |
| ), |
| functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedParameter(name: 'b', type: intNone), |
| ], |
| ), |
| strT0: 'void Function({required int a, int b})', |
| strT1: 'void Function({int b})', |
| ); |
| } |
| |
| test_functionType_requiredNamedParameter_03() { |
| var F0 = functionTypeStar( |
| returnType: voidNone, |
| parameters: [ |
| namedParameter(name: 'a', type: intStar), |
| ], |
| ); |
| |
| var F1 = functionTypeNone( |
| returnType: voidNone, |
| parameters: [ |
| namedRequiredParameter(name: 'a', type: intNone), |
| ], |
| ); |
| |
| isSubtype( |
| F0, |
| F1, |
| strT0: 'void Function({int* a})*', |
| strT1: 'void Function({required int a})', |
| ); |
| |
| isSubtype( |
| F1, |
| F0, |
| strT0: 'void Function({required int a})', |
| strT1: 'void Function({int* a})*', |
| ); |
| } |
| |
| test_futureOr_01() { |
| isSubtype( |
| intStar, |
| futureOrStar(intStar), |
| strT0: 'int*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_02() { |
| isSubtype( |
| intStar, |
| futureOrStar(numStar), |
| strT0: 'int*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_03() { |
| isSubtype( |
| futureStar(intStar), |
| futureOrStar(intStar), |
| strT0: 'Future<int*>*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_04() { |
| isSubtype( |
| futureStar(intStar), |
| futureOrStar(numStar), |
| strT0: 'Future<int*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_05() { |
| isSubtype( |
| futureStar(intStar), |
| futureOrStar(objectStar), |
| strT0: 'Future<int*>*', |
| strT1: 'FutureOr<Object*>*', |
| ); |
| } |
| |
| test_futureOr_06() { |
| isSubtype( |
| futureOrStar(intStar), |
| futureOrStar(intStar), |
| strT0: 'FutureOr<int*>*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_07() { |
| isSubtype( |
| futureOrStar(intStar), |
| futureOrStar(numStar), |
| strT0: 'FutureOr<int*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_08() { |
| isSubtype( |
| futureOrStar(intStar), |
| objectStar, |
| strT0: 'FutureOr<int*>*', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_futureOr_09() { |
| isNotSubtype( |
| intStar, |
| futureOrStar(doubleStar), |
| strT0: 'int*', |
| strT1: 'FutureOr<double*>*', |
| ); |
| } |
| |
| test_futureOr_10() { |
| isNotSubtype( |
| futureOrStar(doubleStar), |
| intStar, |
| strT0: 'FutureOr<double*>*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_futureOr_11() { |
| isNotSubtype( |
| futureOrStar(intStar), |
| futureStar(numStar), |
| strT0: 'FutureOr<int*>*', |
| strT1: 'Future<num*>*', |
| ); |
| } |
| |
| test_futureOr_12() { |
| isNotSubtype( |
| futureOrStar(intStar), |
| numStar, |
| strT0: 'FutureOr<int*>*', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_futureOr_13() { |
| isSubtype( |
| nullQuestion, |
| futureOrStar(intStar), |
| strT0: 'Null?', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_14() { |
| isSubtype( |
| nullQuestion, |
| futureStar(intStar), |
| strT0: 'Null?', |
| strT1: 'Future<int*>*', |
| ); |
| } |
| |
| test_futureOr_15() { |
| isSubtype( |
| dynamicNone, |
| futureOrStar(dynamicNone), |
| strT0: 'dynamic', |
| strT1: 'FutureOr<dynamic>*', |
| ); |
| } |
| |
| test_futureOr_16() { |
| isNotSubtype( |
| dynamicNone, |
| futureOrStar(stringStar), |
| strT0: 'dynamic', |
| strT1: 'FutureOr<String*>*', |
| ); |
| } |
| |
| test_futureOr_17() { |
| isSubtype( |
| voidNone, |
| futureOrStar(voidNone), |
| strT0: 'void', |
| strT1: 'FutureOr<void>*', |
| ); |
| } |
| |
| test_futureOr_18() { |
| isNotSubtype( |
| voidNone, |
| futureOrStar(stringStar), |
| strT0: 'void', |
| strT1: 'FutureOr<String*>*', |
| ); |
| } |
| |
| test_futureOr_19() { |
| var E = typeParameter('E'); |
| |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrStar( |
| typeParameterTypeNone(E), |
| ), |
| strT0: 'E', |
| strT1: 'FutureOr<E>*', |
| ); |
| } |
| |
| test_futureOr_20() { |
| var E = typeParameter('E'); |
| |
| isNotSubtype( |
| typeParameterTypeNone(E), |
| futureOrStar(stringStar), |
| strT0: 'E', |
| strT1: 'FutureOr<String*>*', |
| ); |
| } |
| |
| test_futureOr_21() { |
| isSubtype( |
| functionTypeStar( |
| parameters: const [], |
| returnType: stringStar, |
| ), |
| futureOrStar( |
| functionTypeStar( |
| parameters: const [], |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String* Function()*', |
| strT1: 'FutureOr<void Function()*>*', |
| ); |
| } |
| |
| test_futureOr_22() { |
| isNotSubtype( |
| functionTypeStar( |
| parameters: const [], |
| returnType: voidNone, |
| ), |
| futureOrStar( |
| functionTypeStar( |
| parameters: const [], |
| returnType: stringStar, |
| ), |
| ), |
| strT0: 'void Function()*', |
| strT1: 'FutureOr<String* Function()*>*', |
| ); |
| } |
| |
| test_futureOr_23() { |
| isNotSubtype( |
| futureOrStar(numStar), |
| futureOrStar(intStar), |
| strT0: 'FutureOr<num*>*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_24() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intStar), |
| futureOrStar(numStar), |
| strT0: 'T, T & int*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_25() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureStar(numStar)), |
| futureOrStar(numStar), |
| strT0: 'T, T & Future<num*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_26() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureStar(intStar)), |
| futureOrStar(numStar), |
| strT0: 'T, T & Future<int*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| } |
| |
| test_futureOr_27() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, numStar), |
| futureOrStar(intStar), |
| strT0: 'T, T & num*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_28() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, futureStar(numStar)), |
| futureOrStar(intStar), |
| strT0: 'T, T & Future<num*>*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_29() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, futureOrStar(numStar)), |
| futureOrStar(intStar), |
| strT0: 'T, T & FutureOr<num*>*', |
| strT1: 'FutureOr<int*>*', |
| ); |
| } |
| |
| test_futureOr_30() { |
| isSubtype( |
| futureOrStar(objectStar), |
| futureOrStar( |
| futureOrStar(objectStar), |
| ), |
| strT0: 'FutureOr<Object*>*', |
| strT1: 'FutureOr<FutureOr<Object*>*>*', |
| ); |
| } |
| |
| test_interfaceType_01() { |
| isSubtype(intStar, intStar, strT0: 'int*', strT1: 'int*'); |
| } |
| |
| test_interfaceType_02() { |
| isSubtype(intStar, numStar, strT0: 'int*', strT1: 'num*'); |
| } |
| |
| test_interfaceType_03() { |
| isSubtype( |
| intStar, |
| comparableStar(numStar), |
| strT0: 'int*', |
| strT1: 'Comparable<num*>*', |
| ); |
| } |
| |
| test_interfaceType_04() { |
| isSubtype(intStar, objectStar, strT0: 'int*', strT1: 'Object*'); |
| } |
| |
| test_interfaceType_05() { |
| isSubtype(doubleStar, numStar, strT0: 'double*', strT1: 'num*'); |
| } |
| |
| test_interfaceType_06() { |
| isNotSubtype(intStar, doubleStar, strT0: 'int*', strT1: 'double*'); |
| } |
| |
| test_interfaceType_07() { |
| isNotSubtype( |
| intStar, |
| comparableStar(intStar), |
| strT0: 'int*', |
| strT1: 'Comparable<int*>*', |
| ); |
| } |
| |
| test_interfaceType_08() { |
| isNotSubtype( |
| intStar, |
| iterableStar(intStar), |
| strT0: 'int*', |
| strT1: 'Iterable<int*>*', |
| ); |
| } |
| |
| test_interfaceType_09() { |
| isNotSubtype( |
| comparableStar(intStar), |
| iterableStar(intStar), |
| strT0: 'Comparable<int*>*', |
| strT1: 'Iterable<int*>*', |
| ); |
| } |
| |
| test_interfaceType_10() { |
| isSubtype( |
| listStar(intStar), |
| listStar(intStar), |
| strT0: 'List<int*>*', |
| strT1: 'List<int*>*', |
| ); |
| } |
| |
| test_interfaceType_11() { |
| isSubtype( |
| listStar(intStar), |
| iterableStar(intStar), |
| strT0: 'List<int*>*', |
| strT1: 'Iterable<int*>*', |
| ); |
| } |
| |
| test_interfaceType_12() { |
| isSubtype( |
| listStar(intStar), |
| listStar(numStar), |
| strT0: 'List<int*>*', |
| strT1: 'List<num*>*', |
| ); |
| } |
| |
| test_interfaceType_13() { |
| isSubtype( |
| listStar(intStar), |
| iterableStar(numStar), |
| strT0: 'List<int*>*', |
| strT1: 'Iterable<num*>*', |
| ); |
| } |
| |
| test_interfaceType_14() { |
| isSubtype( |
| listStar(intStar), |
| listStar(objectStar), |
| strT0: 'List<int*>*', |
| strT1: 'List<Object*>*', |
| ); |
| } |
| |
| test_interfaceType_15() { |
| isSubtype( |
| listStar(intStar), |
| iterableStar(objectStar), |
| strT0: 'List<int*>*', |
| strT1: 'Iterable<Object*>*', |
| ); |
| } |
| |
| test_interfaceType_16() { |
| isSubtype( |
| listStar(intStar), |
| objectStar, |
| strT0: 'List<int*>*', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_interfaceType_17() { |
| isSubtype( |
| listStar(intStar), |
| listStar( |
| comparableStar(objectStar), |
| ), |
| strT0: 'List<int*>*', |
| strT1: 'List<Comparable<Object*>*>*', |
| ); |
| } |
| |
| test_interfaceType_18() { |
| isSubtype( |
| listStar(intStar), |
| listStar( |
| comparableStar(numStar), |
| ), |
| strT0: 'List<int*>*', |
| strT1: 'List<Comparable<num*>*>*', |
| ); |
| } |
| |
| test_interfaceType_19() { |
| isSubtype( |
| listStar(intStar), |
| listStar( |
| comparableStar( |
| comparableStar(numStar), |
| ), |
| ), |
| strT0: 'List<int*>*', |
| strT1: 'List<Comparable<Comparable<num*>*>*>*', |
| ); |
| } |
| |
| test_interfaceType_20() { |
| isNotSubtype( |
| listStar(intStar), |
| listStar(doubleStar), |
| strT0: 'List<int*>*', |
| strT1: 'List<double*>*', |
| ); |
| } |
| |
| test_interfaceType_21() { |
| isNotSubtype( |
| listStar(intStar), |
| iterableStar(doubleStar), |
| strT0: 'List<int*>*', |
| strT1: 'Iterable<double*>*', |
| ); |
| } |
| |
| test_interfaceType_22() { |
| isNotSubtype( |
| listStar(intStar), |
| comparableStar(intStar), |
| strT0: 'List<int*>*', |
| strT1: 'Comparable<int*>*', |
| ); |
| } |
| |
| test_interfaceType_23() { |
| isNotSubtype( |
| listStar(intStar), |
| listStar( |
| comparableStar(intStar), |
| ), |
| strT0: 'List<int*>*', |
| strT1: 'List<Comparable<int*>*>*', |
| ); |
| } |
| |
| test_interfaceType_24() { |
| isNotSubtype( |
| listStar(intStar), |
| listStar( |
| comparableStar( |
| comparableStar(intStar), |
| ), |
| ), |
| strT0: 'List<int*>*', |
| strT1: 'List<Comparable<Comparable<int*>*>*>*', |
| ); |
| } |
| |
| test_interfaceType_25_interfaces() { |
| var A = class_(name: 'A'); |
| var I = class_(name: 'I'); |
| |
| A.interfaces = [ |
| I.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ), |
| ]; |
| |
| var A_none = A.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| var I_none = I.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| isSubtype(A_none, I_none, strT0: 'A', strT1: 'I'); |
| isNotSubtype(I_none, A_none, strT0: 'I', strT1: 'A'); |
| } |
| |
| test_interfaceType_26_mixins() { |
| var A = class_(name: 'A'); |
| var M = class_(name: 'M'); |
| |
| A.mixins = [ |
| M.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ), |
| ]; |
| |
| var A_none = A.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| var M_none = M.instantiate( |
| typeArguments: const [], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| isSubtype(A_none, M_none, strT0: 'A', strT1: 'M'); |
| isNotSubtype(M_none, A_none, strT0: 'M', strT1: 'A'); |
| } |
| |
| test_interfaceType_27() { |
| isSubtype(numNone, objectNone, strT0: 'num', strT1: 'Object'); |
| } |
| |
| test_interfaceType_28() { |
| isSubtype(numStar, objectNone, strT0: 'num*', strT1: 'Object'); |
| } |
| |
| test_interfaceType_39() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isSubtype( |
| listNone( |
| promotedTypeParameterTypeNone(T, intNone), |
| ), |
| listNone( |
| typeParameterTypeNone(T), |
| ), |
| strT0: 'List<T>, T extends Object?, T & int', |
| strT1: 'List<T>, T extends Object?', |
| ); |
| } |
| |
| test_interfaceType_40() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isSubtype( |
| listNone( |
| promotedTypeParameterTypeNone(T, intQuestion), |
| ), |
| listNone( |
| typeParameterTypeNone(T), |
| ), |
| strT0: 'List<T>, T extends Object?, T & int?', |
| strT1: 'List<T>, T extends Object?', |
| ); |
| } |
| |
| test_interfaceType_contravariant() { |
| var T = typeParameter('T', variance: Variance.contravariant); |
| var A = class_(name: 'A', typeParameters: [T]); |
| |
| var A_num = A.instantiate( |
| typeArguments: [numNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| var A_int = A.instantiate( |
| typeArguments: [intNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| isSubtype(A_num, A_int, strT0: "A<num>", strT1: "A<int>"); |
| isSubtype(A_num, A_num, strT0: "A<num>", strT1: "A<num>"); |
| isNotSubtype(A_int, A_num, strT0: "A<int>", strT1: "A<num>"); |
| } |
| |
| test_interfaceType_covariant() { |
| var T = typeParameter('T', variance: Variance.covariant); |
| var A = class_(name: 'A', typeParameters: [T]); |
| |
| var A_num = A.instantiate( |
| typeArguments: [numNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| var A_int = A.instantiate( |
| typeArguments: [intNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| isSubtype(A_int, A_num, strT0: "A<int>", strT1: "A<num>"); |
| isSubtype(A_num, A_num, strT0: "A<num>", strT1: "A<num>"); |
| isNotSubtype(A_num, A_int, strT0: "A<num>", strT1: "A<int>"); |
| } |
| |
| test_interfaceType_invariant() { |
| var T = typeParameter('T', variance: Variance.invariant); |
| var A = class_(name: 'A', typeParameters: [T]); |
| |
| var A_num = A.instantiate( |
| typeArguments: [numNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| var A_int = A.instantiate( |
| typeArguments: [intNone], |
| nullabilitySuffix: NullabilitySuffix.none, |
| ); |
| |
| isSubtype(A_num, A_num, strT0: "A<num>", strT1: "A<num>"); |
| isNotSubtype(A_int, A_num, strT0: "A<int>", strT1: "A<num>"); |
| isNotSubtype(A_num, A_int, strT0: "A<num>", strT1: "A<int>"); |
| } |
| |
| test_multi_function_nonGeneric_oneArgument() { |
| isSubtype2('num* Function(num*)*', 'num* Function(int*)*'); |
| isSubtype2('int* Function(num*)*', 'num* Function(num*)*'); |
| isSubtype2('int* Function(num*)*', 'num* Function(int*)*'); |
| isNotSubtype2('int* Function(int*)*', 'num* Function(num*)*'); |
| isSubtype2('Null?', 'num* Function(int*)*'); |
| isSubtype2('Null?', 'num* Function(int*)?'); |
| isSubtype2('Never', 'num* Function(int*)'); |
| isSubtype2('Never', 'num* Function(int*)*'); |
| isSubtype2('Never', 'num* Function(int*)?'); |
| isSubtype2('num* Function(num*)*', 'Object'); |
| isSubtype2('num* Function(num*)', 'Object'); |
| isNotSubtype2('num* Function(num*)?', 'Object'); |
| isNotSubtype2('Null?', 'num* Function(int*)'); |
| isNotSubtype2('num* Function(int*)', 'Never'); |
| |
| isNotSubtype2('num', 'num Function(num)'); |
| isNotSubtype2('Object', 'num Function(num)'); |
| isNotSubtype2('Object*', 'num Function(num)'); |
| isNotSubtype2('Object?', 'num Function(num)'); |
| isNotSubtype2('dynamic', 'num Function(num)'); |
| |
| isSubtype2('num Function(num)', 'num Function(num)*'); |
| isSubtype2('num Function(num)*', 'num Function(num)'); |
| isSubtype2('num Function(num)?', 'num Function(num)*'); |
| isSubtype2('num Function(num)*', 'num Function(num)?'); |
| isSubtype2('num Function(num)', 'num Function(num)?'); |
| isNotSubtype2('num Function(num)?', 'num Function(num)'); |
| |
| isSubtype2('num Function(num)', 'num? Function(num)'); |
| isSubtype2('num Function(num?)', 'num Function(num)'); |
| isSubtype2('num Function(num?)', 'num? Function(num)'); |
| isNotSubtype2('num Function(num)', 'num? Function(num?)'); |
| |
| isSubtype2('num Function({num x})', 'num? Function({num x})'); |
| isSubtype2('num Function({num? x})', 'num Function({num x})'); |
| isSubtype2('num Function({num? x})', 'num? Function({num x})'); |
| isNotSubtype2('num Function({num x})', 'num? Function({num? x})'); |
| |
| isSubtype2('num Function([num])', 'num? Function([num])'); |
| isSubtype2('num Function([num?])', 'num Function([num])'); |
| isSubtype2('num Function([num?])', 'num? Function([num])'); |
| isNotSubtype2('num Function([num])', 'num? Function([num?])'); |
| } |
| |
| test_multi_function_nonGeneric_zeroArguments() { |
| isSubtype2('int* Function()', 'Function'); |
| isSubtype2('int* Function()', 'Function*'); |
| isSubtype2('int* Function()', 'Function?'); |
| |
| isSubtype2('int* Function()*', 'Function'); |
| isSubtype2('int* Function()*', 'Function*'); |
| isSubtype2('int* Function()*', 'Function?'); |
| |
| isNotSubtype2('int* Function()?', 'Function'); |
| isSubtype2('int* Function()?', 'Function*'); |
| isSubtype2('int* Function()?', 'Function?'); |
| |
| isSubtype2('int* Function()', 'Object'); |
| isSubtype2('int* Function()', 'Object*'); |
| isSubtype2('int* Function()', 'Object?'); |
| |
| isSubtype2('int* Function()*', 'Object'); |
| isSubtype2('int* Function()*', 'Object*'); |
| isSubtype2('int* Function()*', 'Object?'); |
| |
| isNotSubtype2('int* Function()?', 'Object'); |
| isSubtype2('int* Function()?', 'Object*'); |
| isSubtype2('int* Function()?', 'Object?'); |
| } |
| |
| test_multi_futureOr() { |
| isSubtype2('int*', 'FutureOr<int*>*'); |
| isSubtype2('int*', 'FutureOr<num*>*'); |
| isSubtype2('Future<int*>*', 'FutureOr<int*>*'); |
| isSubtype2('Future<int*>*', 'FutureOr<num*>*'); |
| isSubtype2('Future<int*>*', 'FutureOr<Object*>*'); |
| isSubtype2('FutureOr<int*>*', 'FutureOr<int*>*'); |
| isSubtype2('FutureOr<int*>*', 'FutureOr<num*>*'); |
| isSubtype2('FutureOr<int*>*', 'Object*'); |
| isSubtype2('Null?', 'FutureOr<num?>'); |
| isSubtype2('Null?', 'FutureOr<num>?'); |
| isSubtype2('num?', 'FutureOr<num?>'); |
| isSubtype2('num?', 'FutureOr<num>?'); |
| isSubtype2('Future<num>', 'FutureOr<num?>'); |
| isSubtype2('Future<num>', 'FutureOr<num>?'); |
| isSubtype2('Future<num>', 'FutureOr<num?>?'); |
| isSubtype2('Future<num?>', 'FutureOr<num?>'); |
| isNotSubtype2('Future<num?>', 'FutureOr<num>?'); |
| isSubtype2('Future<num?>', 'FutureOr<num?>?'); |
| |
| isSubtype2('num?', 'FutureOr<FutureOr<FutureOr<num>>?>'); |
| isSubtype2('Future<num>?', 'FutureOr<FutureOr<FutureOr<num>>?>'); |
| isSubtype2('Future<Future<num>>?', 'FutureOr<FutureOr<FutureOr<num>>?>'); |
| isSubtype2( |
| 'Future<Future<Future<num>>>?', |
| 'FutureOr<FutureOr<FutureOr<num>>?>', |
| ); |
| isSubtype2('Future<num>?', 'FutureOr<FutureOr<FutureOr<num?>>>'); |
| isSubtype2('Future<Future<num>>?', 'FutureOr<FutureOr<FutureOr<num?>>>'); |
| isSubtype2( |
| 'Future<Future<Future<num>>>?', |
| 'FutureOr<FutureOr<FutureOr<num?>>>', |
| ); |
| isSubtype2('Future<num?>?', 'FutureOr<FutureOr<FutureOr<num?>>>'); |
| isSubtype2('Future<Future<num?>?>?', 'FutureOr<FutureOr<FutureOr<num?>>>'); |
| isSubtype2( |
| 'Future<Future<Future<num?>?>?>?', |
| 'FutureOr<FutureOr<FutureOr<num?>>>', |
| ); |
| |
| isSubtype2('FutureOr<num>?', 'FutureOr<num?>'); |
| isNotSubtype2('FutureOr<num?>', 'FutureOr<num>?'); |
| |
| isSubtype2('dynamic', 'FutureOr<Object?>'); |
| isSubtype2('dynamic', 'FutureOr<Object>?'); |
| isSubtype2('void', 'FutureOr<Object?>'); |
| isSubtype2('void', 'FutureOr<Object>?'); |
| isSubtype2('Object*', 'FutureOr<Object?>'); |
| isSubtype2('Object*', 'FutureOr<Object>?'); |
| isSubtype2('Object?', 'FutureOr<Object?>'); |
| isSubtype2('Object?', 'FutureOr<Object>?'); |
| isSubtype2('Object', 'FutureOr<Object?>'); |
| isSubtype2('Object', 'FutureOr<Object>?'); |
| isNotSubtype2('dynamic', 'FutureOr<Object>'); |
| isNotSubtype2('void', 'FutureOr<Object>'); |
| isNotSubtype2('Object?', 'FutureOr<Object>'); |
| isSubtype2('Object', 'FutureOr<Object>'); |
| |
| isSubtype2('FutureOr<int>', 'Object'); |
| isSubtype2('FutureOr<int>', 'Object*'); |
| isSubtype2('FutureOr<int>', 'Object?'); |
| |
| isSubtype2('FutureOr<int>*', 'Object'); |
| isSubtype2('FutureOr<int>*', 'Object*'); |
| isSubtype2('FutureOr<int>*', 'Object?'); |
| |
| isNotSubtype2('FutureOr<int>?', 'Object'); |
| isSubtype2('FutureOr<int>?', 'Object*'); |
| isSubtype2('FutureOr<int>?', 'Object?'); |
| |
| isSubtype2('FutureOr<int*>', 'Object'); |
| isSubtype2('FutureOr<int*>', 'Object*'); |
| isSubtype2('FutureOr<int*>', 'Object?'); |
| |
| isNotSubtype2('FutureOr<int?>', 'Object'); |
| isSubtype2('FutureOr<int?>', 'Object*'); |
| isSubtype2('FutureOr<int?>', 'Object?'); |
| |
| isSubtype2('FutureOr<Future<Object>>', 'Future<Object>'); |
| isNotSubtype2('FutureOr<Future<Object>>?', 'Future<Object>'); |
| isNotSubtype2('FutureOr<Future<Object>?>', 'Future<Object>'); |
| isNotSubtype2('FutureOr<Future<Object>?>?', 'Future<Object>'); |
| |
| isSubtype2('FutureOr<num>', 'Object'); |
| isSubtype2('FutureOr<num>*', 'Object'); |
| isNotSubtype2('FutureOr<num>?', 'Object'); |
| } |
| |
| test_multi_futureOr_functionType() { |
| isSubtype( |
| functionTypeStar( |
| returnType: stringStar, |
| ), |
| futureOrStar( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String* Function()*', |
| strT1: 'FutureOr<void Function()*>*', |
| ); |
| |
| isSubtype( |
| functionTypeNone( |
| returnType: stringNone, |
| ), |
| futureOrNone( |
| functionTypeNone( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()', |
| strT1: 'FutureOr<void Function()>', |
| ); |
| |
| isSubtype( |
| functionTypeNone( |
| returnType: stringNone, |
| ), |
| futureOrNone( |
| functionTypeQuestion( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()', |
| strT1: 'FutureOr<void Function()?>', |
| ); |
| |
| isSubtype( |
| functionTypeNone( |
| returnType: stringNone, |
| ), |
| futureOrQuestion( |
| functionTypeNone( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()', |
| strT1: 'FutureOr<void Function()>?', |
| ); |
| |
| isSubtype( |
| functionTypeQuestion( |
| returnType: stringNone, |
| ), |
| futureOrNone( |
| functionTypeQuestion( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()?', |
| strT1: 'FutureOr<void Function()?>', |
| ); |
| |
| isSubtype( |
| functionTypeQuestion( |
| returnType: stringNone, |
| ), |
| futureOrQuestion( |
| functionTypeNone( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()?', |
| strT1: 'FutureOr<void Function()>?', |
| ); |
| |
| isNotSubtype( |
| functionTypeQuestion( |
| returnType: stringNone, |
| ), |
| futureOrNone( |
| functionTypeNone( |
| returnType: voidNone, |
| ), |
| ), |
| strT0: 'String Function()?', |
| strT1: 'FutureOr<void Function()>', |
| ); |
| |
| isNotSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| futureOrStar( |
| functionTypeStar( |
| returnType: stringNone, |
| ), |
| ), |
| strT0: 'void Function()*', |
| strT1: 'FutureOr<String Function()*>*', |
| ); |
| } |
| |
| test_multi_futureOr_typeParameter() { |
| TypeParameterElement E; |
| |
| E = typeParameter('E', bound: objectStar); |
| isSubtype( |
| typeParameterTypeStar(E), |
| futureOrStar( |
| typeParameterTypeStar(E), |
| ), |
| strT0: 'E*, E extends Object*', |
| strT1: 'FutureOr<E*>*, E extends Object*', |
| ); |
| |
| E = typeParameter('E', bound: objectNone); |
| isSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrQuestion( |
| typeParameterTypeNone(E), |
| ), |
| strT0: 'E?, E extends Object', |
| strT1: 'FutureOr<E>?, E extends Object', |
| ); |
| isSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrNone( |
| typeParameterTypeQuestion(E), |
| ), |
| strT0: 'E?, E extends Object', |
| strT1: 'FutureOr<E?>, E extends Object', |
| ); |
| isNotSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrNone( |
| typeParameterTypeNone(E), |
| ), |
| strT0: 'E?, E extends Object', |
| strT1: 'FutureOr<E>, E extends Object', |
| ); |
| |
| E = typeParameter('E', bound: objectQuestion); |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrQuestion( |
| typeParameterTypeNone(E), |
| ), |
| strT0: 'E, E extends Object?', |
| strT1: 'FutureOr<E>?, E extends Object?', |
| ); |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrNone( |
| typeParameterTypeQuestion(E), |
| ), |
| strT0: 'E, E extends Object?', |
| strT1: 'FutureOr<E?>, E extends Object?', |
| ); |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrNone( |
| typeParameterTypeNone(E), |
| ), |
| strT0: 'E, E extends Object?', |
| strT1: 'FutureOr<E>, E extends Object?', |
| ); |
| |
| E = typeParameter('E', bound: objectStar); |
| isNotSubtype( |
| typeParameterTypeStar(E), |
| futureOrStar(stringStar), |
| strT0: 'E*, E extends Object*', |
| strT1: 'FutureOr<String*>*', |
| ); |
| |
| E = typeParameter('E', bound: stringNone); |
| isSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrQuestion(stringNone), |
| strT0: 'E?, E extends String', |
| strT1: 'FutureOr<String>?', |
| ); |
| isSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrNone(stringQuestion), |
| strT0: 'E?, E extends String', |
| strT1: 'FutureOr<String?>', |
| ); |
| isNotSubtype( |
| typeParameterTypeQuestion(E), |
| futureOrNone(stringNone), |
| strT0: 'E?, E extends String', |
| strT1: 'FutureOr<String>', |
| ); |
| |
| E = typeParameter('E', bound: stringQuestion); |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrQuestion(stringNone), |
| strT0: 'E, E extends String?', |
| strT1: 'FutureOr<String>?', |
| ); |
| isSubtype( |
| typeParameterTypeNone(E), |
| futureOrNone(stringQuestion), |
| strT0: 'E, E extends String?', |
| strT1: 'FutureOr<String?>', |
| ); |
| isNotSubtype( |
| typeParameterTypeNone(E), |
| futureOrNone(stringNone), |
| strT0: 'E, E extends String?', |
| strT1: 'FutureOr<String>', |
| ); |
| } |
| |
| test_multi_futureOr_typeParameter_promotion() { |
| TypeParameterElement S; |
| TypeParameterElement T; |
| |
| T = typeParameter('T', bound: objectStar); |
| isSubtype( |
| promotedTypeParameterTypeStar(T, intStar), |
| futureOrStar(numStar), |
| strT0: 'T*, T extends Object*, T & int*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| |
| T = typeParameter('T', bound: objectNone); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object, T & int', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object, T & int', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object, T & int', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| T = typeParameter('T', bound: objectQuestion); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object?, T & int', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object?, T & int', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intNone), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object?, T & int', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| T = typeParameter('T', bound: objectQuestion); |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, intQuestion), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object?, T & int?', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intQuestion), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object?, T & int?', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intQuestion), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object?, T & int?', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| T = typeParameter('T', bound: objectQuestion); |
| S = typeParameter('S', bound: typeParameterTypeNone(T)); |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), |
| futureOrNone(objectNone), |
| strT0: 'T, T extends Object?, T & S', |
| strT1: 'FutureOr<Object>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), |
| futureOrNone(objectQuestion), |
| strT0: 'T, T extends Object?, T & S', |
| strT1: 'FutureOr<Object?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), |
| futureOrQuestion(objectNone), |
| strT0: 'T, T extends Object?, T & S', |
| strT1: 'FutureOr<Object>?', |
| ); |
| |
| T = typeParameter('T', bound: objectStar); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureStar(numStar)), |
| futureOrStar(numStar), |
| strT0: 'T, T extends Object*, T & Future<num*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureStar(intStar)), |
| futureOrStar(numStar), |
| strT0: 'T, T extends Object*, T & Future<int*>*', |
| strT1: 'FutureOr<num*>*', |
| ); |
| |
| T = typeParameter('T', bound: objectNone); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object, T & Future<int>', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object, T & Future<int>', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object, T & Future<int>', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| T = typeParameter('T', bound: objectQuestion); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object?, T & Future<int>', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object?, T & Future<int>', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intNone)), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object?, T & Future<int>', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, futureQuestion(intNone)), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object?, T & Future<int>?', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureQuestion(intNone)), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object?, T & Future<int>?', |
| strT1: 'FutureOr<num?>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureQuestion(intNone)), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object?, T & Future<int>?', |
| strT1: 'FutureOr<num>?', |
| ); |
| |
| T = typeParameter('T', bound: objectNone); |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intQuestion)), |
| futureOrNone(numNone), |
| strT0: 'T, T extends Object, T & Future<int?>', |
| strT1: 'FutureOr<num>', |
| ); |
| isSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intQuestion)), |
| futureOrNone(numQuestion), |
| strT0: 'T, T extends Object, T & Future<int?>', |
| strT1: 'FutureOr<num?>', |
| ); |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, futureNone(intQuestion)), |
| futureOrQuestion(numNone), |
| strT0: 'T, T extends Object, T & Future<int?>', |
| strT1: 'FutureOr<num>?', |
| ); |
| } |
| |
| test_multi_list_subTypes_superTypes() { |
| isSubtype2('List<int*>*', 'List<int*>*'); |
| isSubtype2('List<int*>*', 'Iterable<int*>*'); |
| isSubtype2('List<int*>*', 'List<num*>*'); |
| isSubtype2('List<int*>*', 'Iterable<num*>*'); |
| isSubtype2('List<int*>*', 'List<Object*>*'); |
| isSubtype2('List<int*>*', 'Iterable<Object*>*'); |
| isSubtype2('List<int*>*', 'Object*'); |
| isSubtype2('List<int*>*', 'List<Comparable<Object*>*>*'); |
| isSubtype2('List<int*>*', 'List<Comparable<num*>*>*'); |
| isSubtype2('List<int*>*', 'List<Comparable<Comparable<num*>*>*>*'); |
| isSubtype2('List<int*>', 'Object'); |
| isSubtype2('List<int*>*', 'Object'); |
| isSubtype2('Null?', 'List<int*>*'); |
| isSubtype2('Null?', 'List<int*>?'); |
| isSubtype2('Never', 'List<int*>'); |
| isSubtype2('Never', 'List<int*>*'); |
| isSubtype2('Never', 'List<int*>?'); |
| |
| isSubtype2('List<int>', 'List<int>'); |
| isSubtype2('List<int>', 'List<int>*'); |
| isSubtype2('List<int>', 'List<int>?'); |
| isSubtype2('List<int>*', 'List<int>'); |
| isSubtype2('List<int>*', 'List<int>*'); |
| isSubtype2('List<int>*', 'List<int>?'); |
| isNotSubtype2('List<int>?', 'List<int>'); |
| isSubtype2('List<int>?', 'List<int>*'); |
| isSubtype2('List<int>?', 'List<int>?'); |
| |
| isSubtype2('List<int>', 'List<int*>'); |
| isSubtype2('List<int>', 'List<int?>'); |
| isSubtype2('List<int*>', 'List<int>'); |
| isSubtype2('List<int*>', 'List<int*>'); |
| isSubtype2('List<int*>', 'List<int?>'); |
| isNotSubtype2('List<int?>', 'List<int>'); |
| isSubtype2('List<int?>', 'List<int*>'); |
| isSubtype2('List<int?>', 'List<int?>'); |
| } |
| |
| test_multi_never() { |
| isSubtype2('Never', 'FutureOr<num>'); |
| isSubtype2('Never', 'FutureOr<num*>'); |
| isSubtype2('Never', 'FutureOr<num>*'); |
| isSubtype2('Never', 'FutureOr<num?>'); |
| isSubtype2('Never', 'FutureOr<num>?'); |
| isNotSubtype2('FutureOr<num>', 'Never'); |
| } |
| |
| test_multi_num_subTypes_superTypes() { |
| isSubtype2('int*', 'num*'); |
| isSubtype2('int*', 'Comparable<num*>*'); |
| isSubtype2('int*', 'Comparable<Object*>*'); |
| isSubtype2('int*', 'Object*'); |
| isSubtype2('double*', 'num*'); |
| isSubtype2('num', 'Object'); |
| isSubtype2('num*', 'Object'); |
| isSubtype2('Null?', 'num*'); |
| isSubtype2('Null?', 'num?'); |
| isSubtype2('Never', 'num'); |
| isSubtype2('Never', 'num*'); |
| isSubtype2('Never', 'num?'); |
| |
| isNotSubtype2('int*', 'double*'); |
| isNotSubtype2('int*', 'Comparable<int*>*'); |
| isNotSubtype2('int*', 'Iterable<int*>*'); |
| isNotSubtype2('Comparable<int*>*', 'Iterable<int*>*'); |
| isNotSubtype2('num?', 'Object'); |
| isNotSubtype2('Null?', 'num'); |
| isNotSubtype2('num', 'Never'); |
| } |
| |
| test_multi_object_topAndBottom() { |
| isSubtype2('Never', 'Object'); |
| isSubtype2('Object', 'dynamic'); |
| isSubtype2('Object', 'void'); |
| isSubtype2('Object', 'Object?'); |
| isSubtype2('Object', 'Object*'); |
| isSubtype2('Object*', 'Object'); |
| |
| isNotSubtype2('Object', 'Never'); |
| isNotSubtype2('Object', 'Null?'); |
| isNotSubtype2('dynamic', 'Object'); |
| isNotSubtype2('void', 'Object'); |
| isNotSubtype2('Object?', 'Object'); |
| } |
| |
| test_multi_special() { |
| isNotSubtype2('dynamic', 'int'); |
| isNotSubtype2('dynamic', 'int*'); |
| isNotSubtype2('dynamic', 'int?'); |
| |
| isNotSubtype2('void', 'int'); |
| isNotSubtype2('void', 'int*'); |
| isNotSubtype2('void', 'int?'); |
| |
| isNotSubtype2('Object', 'int'); |
| isNotSubtype2('Object', 'int*'); |
| isNotSubtype2('Object', 'int?'); |
| |
| isNotSubtype2('Object*', 'int'); |
| isNotSubtype2('Object*', 'int*'); |
| isNotSubtype2('Object*', 'int?'); |
| |
| isNotSubtype2('Object?', 'int'); |
| isNotSubtype2('Object?', 'int*'); |
| isNotSubtype2('Object?', 'int?'); |
| |
| isNotSubtype2('int* Function()*', 'int*'); |
| } |
| |
| test_multi_topAndBottom() { |
| isSubtype2('Null?', 'Null?'); |
| isSubtype2('Never', 'Null?'); |
| isSubtype2('Never', 'Never'); |
| isNotSubtype2('Null?', 'Never'); |
| |
| isSubtype2('Null?', 'Never?'); |
| isSubtype2('Never?', 'Null?'); |
| isSubtype2('Never', 'Never?'); |
| isNotSubtype2('Never?', 'Never'); |
| |
| isSubtype2('Object*', 'Object*'); |
| isSubtype2('Object*', 'dynamic'); |
| isSubtype2('Object*', 'void'); |
| isSubtype2('Object*', 'Object?'); |
| isSubtype2('dynamic', 'Object*'); |
| isSubtype2('dynamic', 'dynamic'); |
| isSubtype2('dynamic', 'void'); |
| isSubtype2('dynamic', 'Object?'); |
| isSubtype2('void', 'Object*'); |
| isSubtype2('void', 'dynamic'); |
| isSubtype2('void', 'void'); |
| isSubtype2('void', 'Object?'); |
| isSubtype2('Object?', 'Object*'); |
| isSubtype2('Object?', 'dynamic'); |
| isSubtype2('Object?', 'void'); |
| isSubtype2('Object?', 'Object?'); |
| |
| isSubtype2('Never', 'Object?'); |
| isSubtype2('Never', 'Object*'); |
| isSubtype2('Never', 'dynamic'); |
| isSubtype2('Never', 'void'); |
| isSubtype2('Null?', 'Object?'); |
| isSubtype2('Null?', 'Object*'); |
| isSubtype2('Null?', 'dynamic'); |
| isSubtype2('Null?', 'void'); |
| |
| isNotSubtype2('Object?', 'Never'); |
| isNotSubtype2('Object?', 'Null?'); |
| isNotSubtype2('Object*', 'Never'); |
| isNotSubtype2('Object*', 'Null?'); |
| isNotSubtype2('dynamic', 'Never'); |
| isNotSubtype2('dynamic', 'Null?'); |
| isNotSubtype2('void', 'Never'); |
| isNotSubtype2('void', 'Null?'); |
| } |
| |
| test_multi_typeParameter_promotion() { |
| TypeParameterElement T; |
| |
| T = typeParameter('T', bound: intStar); |
| isSubtype( |
| typeParameterTypeStar(T), |
| promotedTypeParameterTypeStar(T, intStar), |
| strT0: 'T*, T extends int*', |
| strT1: 'T*, T extends int*, T & int*', |
| ); |
| |
| T = typeParameter('T', bound: intNone); |
| isSubtype( |
| typeParameterTypeNone(T), |
| promotedTypeParameterTypeNone(T, intNone), |
| strT0: 'T, T extends int', |
| strT1: 'T, T extends int, T & int', |
| ); |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| promotedTypeParameterTypeNone(T, intNone), |
| strT0: 'T?, T extends int', |
| strT1: 'T, T extends int, T & int', |
| ); |
| |
| T = typeParameter('T', bound: intQuestion); |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| promotedTypeParameterTypeNone(T, intNone), |
| strT0: 'T, T extends int?', |
| strT1: 'T, T extends int?, T & int', |
| ); |
| isSubtype( |
| typeParameterTypeNone(T), |
| promotedTypeParameterTypeNone(T, intQuestion), |
| strT0: 'T, T extends int?', |
| strT1: 'T, T extends int?, T & int?', |
| ); |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| promotedTypeParameterTypeNone(T, intQuestion), |
| strT0: 'T?, T extends int?', |
| strT1: 'T, T extends int?, T & int?', |
| ); |
| |
| T = typeParameter('T', bound: numStar); |
| isSubtype( |
| typeParameterTypeStar(T), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends num*', |
| strT1: 'T*, T extends num*', |
| ); |
| |
| T = typeParameter('T', bound: numNone); |
| isSubtype( |
| typeParameterTypeNone(T), |
| typeParameterTypeNone(T), |
| strT0: 'T, T extends num', |
| strT1: 'T, T extends num', |
| ); |
| isSubtype( |
| typeParameterTypeQuestion(T), |
| typeParameterTypeQuestion(T), |
| strT0: 'T?, T extends num', |
| strT1: 'T?, T extends num', |
| ); |
| |
| T = typeParameter('T', bound: numQuestion); |
| isSubtype( |
| typeParameterTypeNone(T), |
| typeParameterTypeNone(T), |
| strT0: 'T, T extends num?', |
| strT1: 'T, T extends num?', |
| ); |
| isSubtype( |
| typeParameterTypeQuestion(T), |
| typeParameterTypeQuestion(T), |
| strT0: 'T?, T extends num?', |
| strT1: 'T?, T extends num?', |
| ); |
| } |
| |
| test_never_01() { |
| isSubtype( |
| neverNone, |
| neverNone, |
| strT0: 'Never', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_02() { |
| isSubtype(neverNone, numNone, strT0: 'Never', strT1: 'num'); |
| } |
| |
| test_never_03() { |
| isSubtype(neverNone, numStar, strT0: 'Never', strT1: 'num*'); |
| } |
| |
| test_never_04() { |
| isSubtype(neverNone, numQuestion, strT0: 'Never', strT1: 'num?'); |
| } |
| |
| test_never_05() { |
| isNotSubtype(numNone, neverNone, strT0: 'num', strT1: 'Never'); |
| } |
| |
| test_never_06() { |
| isSubtype( |
| neverNone, |
| listNone(intStar), |
| strT0: 'Never', |
| strT1: 'List<int*>', |
| ); |
| } |
| |
| test_never_09() { |
| isNotSubtype( |
| numNone, |
| neverNone, |
| strT0: 'num', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_15() { |
| var T = typeParameter('T', bound: objectStar); |
| |
| isSubtype( |
| neverNone, |
| promotedTypeParameterTypeStar(T, numStar), |
| strT0: 'Never', |
| strT1: 'T*, T extends Object*, T & num*', |
| ); |
| } |
| |
| test_never_16() { |
| var T = typeParameter('T', bound: objectStar); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeStar(T, numStar), |
| neverNone, |
| strT0: 'T*, T extends Object*, T & num*', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_17() { |
| var T = typeParameter('T', bound: neverNone); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| neverNone, |
| strT0: 'T, T extends Never', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_18() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, neverNone), |
| neverNone, |
| strT0: 'T, T extends Object, T & Never', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_19() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isSubtype( |
| neverNone, |
| typeParameterTypeQuestion(T), |
| strT0: 'Never', |
| strT1: 'T?, T extends Object', |
| ); |
| } |
| |
| test_never_20() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isSubtype( |
| neverNone, |
| typeParameterTypeQuestion(T), |
| strT0: 'Never', |
| strT1: 'T?, T extends Object?', |
| ); |
| } |
| |
| test_never_21() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isSubtype( |
| neverNone, |
| typeParameterTypeNone(T), |
| strT0: 'Never', |
| strT1: 'T, T extends Object', |
| ); |
| } |
| |
| test_never_22() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isSubtype( |
| neverNone, |
| typeParameterTypeNone(T), |
| strT0: 'Never', |
| strT1: 'T, T extends Object?', |
| ); |
| } |
| |
| test_never_23() { |
| var T = typeParameter('T', bound: neverNone); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| neverNone, |
| strT0: 'T, T extends Never', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_24() { |
| var T = typeParameter('T', bound: neverQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| neverNone, |
| strT0: 'T, T extends Never?', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_25() { |
| var T = typeParameter('T', bound: neverNone); |
| |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| neverNone, |
| strT0: 'T?, T extends Never', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_26() { |
| var T = typeParameter('T', bound: neverQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| neverNone, |
| strT0: 'T?, T extends Never?', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_27() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| neverNone, |
| strT0: 'T, T extends Object', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_28() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| neverNone, |
| strT0: 'T, T extends Object?', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_never_29() { |
| isSubtype(neverNone, nullQuestion, strT0: 'Never', strT1: 'Null?'); |
| } |
| |
| test_null_01() { |
| isNotSubtype( |
| nullQuestion, |
| neverNone, |
| strT0: 'Null?', |
| strT1: 'Never', |
| ); |
| } |
| |
| test_null_02() { |
| isSubtype( |
| nullQuestion, |
| objectStar, |
| strT0: 'Null?', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_null_03() { |
| isSubtype( |
| nullQuestion, |
| voidNone, |
| strT0: 'Null?', |
| strT1: 'void', |
| ); |
| } |
| |
| test_null_04() { |
| isSubtype( |
| nullQuestion, |
| dynamicNone, |
| strT0: 'Null?', |
| strT1: 'dynamic', |
| ); |
| } |
| |
| test_null_05() { |
| isSubtype( |
| nullQuestion, |
| doubleStar, |
| strT0: 'Null?', |
| strT1: 'double*', |
| ); |
| } |
| |
| test_null_06() { |
| isSubtype( |
| nullQuestion, |
| doubleQuestion, |
| strT0: 'Null?', |
| strT1: 'double?', |
| ); |
| } |
| |
| test_null_07() { |
| isSubtype( |
| nullQuestion, |
| comparableStar(objectStar), |
| strT0: 'Null?', |
| strT1: 'Comparable<Object*>*', |
| ); |
| } |
| |
| test_null_08() { |
| var T = typeParameter('T', bound: objectStar); |
| |
| isNotSubtype( |
| nullQuestion, |
| typeParameterTypeNone(T), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object*', |
| ); |
| } |
| |
| test_null_09() { |
| isSubtype( |
| nullQuestion, |
| nullQuestion, |
| strT0: 'Null?', |
| strT1: 'Null?', |
| ); |
| } |
| |
| test_null_10() { |
| isNotSubtype( |
| nullQuestion, |
| listNone(intStar), |
| strT0: 'Null?', |
| strT1: 'List<int*>', |
| ); |
| } |
| |
| test_null_13() { |
| isNotSubtype( |
| nullQuestion, |
| functionTypeNone( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| strT0: 'Null?', |
| strT1: 'num* Function(int*)', |
| ); |
| } |
| |
| test_null_14() { |
| isSubtype( |
| nullQuestion, |
| functionTypeStar( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| strT0: 'Null?', |
| strT1: 'num* Function(int*)*', |
| ); |
| } |
| |
| test_null_15() { |
| isSubtype( |
| nullQuestion, |
| functionTypeQuestion( |
| returnType: numStar, |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| ), |
| strT0: 'Null?', |
| strT1: 'num* Function(int*)?', |
| ); |
| } |
| |
| test_null_16() { |
| var T = typeParameter('T', bound: objectStar); |
| |
| isSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeStar(T, numStar), |
| strT0: 'Null?', |
| strT1: 'T*, T extends Object*, T & num*', |
| ); |
| } |
| |
| test_null_17() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isNotSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeNone(T, numNone), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object?, T & num', |
| ); |
| } |
| |
| test_null_18() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isNotSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeNone(T, numQuestion), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object?, T & num?', |
| ); |
| } |
| |
| test_null_19() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isNotSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeNone(T, numNone), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object, T & num', |
| ); |
| } |
| |
| test_null_20() { |
| var T = typeParameter('T', bound: objectQuestion); |
| var S = typeParameter('S', bound: typeParameterTypeNone(T)); |
| |
| isNotSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object?, T & S', |
| ); |
| } |
| |
| test_null_21() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isSubtype( |
| nullQuestion, |
| typeParameterTypeQuestion(T), |
| strT0: 'Null?', |
| strT1: 'T?, T extends Object', |
| ); |
| } |
| |
| test_null_22() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isSubtype( |
| nullQuestion, |
| typeParameterTypeQuestion(T), |
| strT0: 'Null?', |
| strT1: 'T?, T extends Object?', |
| ); |
| } |
| |
| test_null_23() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isNotSubtype( |
| nullQuestion, |
| typeParameterTypeNone(T), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object', |
| ); |
| } |
| |
| test_null_24() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isNotSubtype( |
| nullQuestion, |
| typeParameterTypeNone(T), |
| strT0: 'Null?', |
| strT1: 'T, T extends Object?', |
| ); |
| } |
| |
| test_null_25() { |
| var T = typeParameter('T', bound: nullQuestion); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| nullQuestion, |
| strT0: 'T, T extends Null?', |
| strT1: 'Null?', |
| ); |
| } |
| |
| test_null_26() { |
| var T = typeParameter('T', bound: nullQuestion); |
| |
| isSubtype( |
| typeParameterTypeQuestion(T), |
| nullQuestion, |
| strT0: 'T?, T extends Null?', |
| strT1: 'Null?', |
| ); |
| } |
| |
| test_null_27() { |
| var T = typeParameter('T', bound: objectNone); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| nullQuestion, |
| strT0: 'T, T extends Object', |
| strT1: 'Null?', |
| ); |
| } |
| |
| test_null_28() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| nullQuestion, |
| strT0: 'T, T extends Object?', |
| strT1: 'Null?', |
| ); |
| } |
| |
| test_null_29() { |
| isSubtype( |
| nullQuestion, |
| comparableQuestion(objectStar), |
| strT0: 'Null?', |
| strT1: 'Comparable<Object*>?', |
| ); |
| } |
| |
| test_null_30() { |
| isNotSubtype(nullQuestion, objectNone, strT0: 'Null?', strT1: 'Object'); |
| } |
| |
| test_nullabilitySuffix_01() { |
| isSubtype(intNone, intNone, strT0: 'int', strT1: 'int'); |
| isSubtype(intNone, intQuestion, strT0: 'int', strT1: 'int?'); |
| isSubtype(intNone, intStar, strT0: 'int', strT1: 'int*'); |
| |
| isNotSubtype(intQuestion, intNone, strT0: 'int?', strT1: 'int'); |
| isSubtype(intQuestion, intQuestion, strT0: 'int?', strT1: 'int?'); |
| isSubtype(intQuestion, intStar, strT0: 'int?', strT1: 'int*'); |
| |
| isSubtype(intStar, intNone, strT0: 'int*', strT1: 'int'); |
| isSubtype(intStar, intQuestion, strT0: 'int*', strT1: 'int?'); |
| isSubtype(intStar, intStar, strT0: 'int*', strT1: 'int*'); |
| } |
| |
| test_nullabilitySuffix_05() { |
| isSubtype( |
| functionTypeNone( |
| parameters: [ |
| requiredParameter(type: intNone), |
| ], |
| returnType: voidNone, |
| ), |
| objectNone, |
| strT0: 'void Function(int)', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_nullabilitySuffix_11() { |
| isSubtype( |
| intQuestion, |
| intQuestion, |
| strT0: 'int?', |
| strT1: 'int?', |
| ); |
| } |
| |
| test_nullabilitySuffix_12() { |
| isSubtype( |
| intStar, |
| intStar, |
| strT0: 'int*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_nullabilitySuffix_13() { |
| var f = functionTypeQuestion( |
| parameters: [ |
| requiredParameter(type: intNone), |
| ], |
| returnType: intNone, |
| ); |
| isSubtype( |
| f, |
| f, |
| strT0: 'int Function(int)?', |
| strT1: 'int Function(int)?', |
| ); |
| } |
| |
| test_nullabilitySuffix_14() { |
| var f = functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intNone), |
| ], |
| returnType: intNone, |
| ); |
| isSubtype( |
| f, |
| f, |
| strT0: 'int Function(int)*', |
| strT1: 'int Function(int)*', |
| ); |
| } |
| |
| test_nullabilitySuffix_15() { |
| var f = functionTypeNone( |
| parameters: [ |
| requiredParameter(type: intNone), |
| requiredParameter(type: intStar), |
| requiredParameter(type: intQuestion), |
| ], |
| returnType: intQuestion, |
| ); |
| isSubtype( |
| f, |
| f, |
| strT0: 'int? Function(int, int*, int?)', |
| strT1: 'int? Function(int, int*, int?)', |
| ); |
| } |
| |
| test_nullabilitySuffix_16() { |
| var type = listQuestion(intNone); |
| isSubtype( |
| type, |
| type, |
| strT0: 'List<int>?', |
| strT1: 'List<int>?', |
| ); |
| } |
| |
| test_nullabilitySuffix_17() { |
| var type = listQuestion(intQuestion); |
| isSubtype( |
| type, |
| type, |
| strT0: 'List<int?>?', |
| strT1: 'List<int?>?', |
| ); |
| } |
| |
| test_nullabilitySuffix_18() { |
| var T = typeParameter('T', bound: objectStar); |
| var type = promotedTypeParameterTypeNone(T, intQuestion); |
| isSubtype( |
| type, |
| type, |
| strT0: 'T, T extends Object*, T & int?', |
| strT1: 'T, T extends Object*, T & int?', |
| ); |
| } |
| |
| test_nullabilitySuffix_19() { |
| var T = typeParameter('T', bound: objectNone); |
| var type = promotedTypeParameterTypeQuestion(T, intQuestion); |
| isSubtype( |
| type, |
| type, |
| strT0: 'T?, T extends Object, T & int?', |
| strT1: 'T?, T extends Object, T & int?', |
| ); |
| } |
| |
| test_special_01() { |
| isNotSubtype( |
| dynamicNone, |
| intStar, |
| strT0: 'dynamic', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_special_02() { |
| isNotSubtype( |
| voidNone, |
| intStar, |
| strT0: 'void', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_special_03() { |
| isNotSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| intStar, |
| strT0: 'int* Function()*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_special_04() { |
| isNotSubtype( |
| intStar, |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| strT0: 'int*', |
| strT1: 'int* Function()*', |
| ); |
| } |
| |
| test_special_06() { |
| isSubtype( |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| objectStar, |
| strT0: 'int* Function()*', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_special_07() { |
| isSubtype( |
| objectStar, |
| objectStar, |
| strT0: 'Object*', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_special_08() { |
| isSubtype( |
| objectStar, |
| dynamicNone, |
| strT0: 'Object*', |
| strT1: 'dynamic', |
| ); |
| } |
| |
| test_special_09() { |
| isSubtype( |
| objectStar, |
| voidNone, |
| strT0: 'Object*', |
| strT1: 'void', |
| ); |
| } |
| |
| test_special_10() { |
| isSubtype( |
| dynamicNone, |
| objectStar, |
| strT0: 'dynamic', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_special_11() { |
| isSubtype( |
| dynamicNone, |
| dynamicNone, |
| strT0: 'dynamic', |
| strT1: 'dynamic', |
| ); |
| } |
| |
| test_special_12() { |
| isSubtype( |
| dynamicNone, |
| voidNone, |
| strT0: 'dynamic', |
| strT1: 'void', |
| ); |
| } |
| |
| test_special_13() { |
| isSubtype( |
| voidNone, |
| objectStar, |
| strT0: 'void', |
| strT1: 'Object*', |
| ); |
| } |
| |
| test_special_14() { |
| isSubtype( |
| voidNone, |
| dynamicNone, |
| strT0: 'void', |
| strT1: 'dynamic', |
| ); |
| } |
| |
| test_special_15() { |
| isSubtype( |
| voidNone, |
| voidNone, |
| strT0: 'void', |
| strT1: 'void', |
| ); |
| } |
| |
| test_top_01() { |
| var S = typeParameter('S', bound: objectStar); |
| var T = typeParameter('T', bound: voidNone); |
| var U = typeParameter('U', bound: dynamicNone); |
| var V = typeParameter('V', bound: objectStar); |
| |
| isSubtype( |
| functionTypeStar( |
| typeFormals: [S, T], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(S)), |
| requiredParameter(type: typeParameterTypeNone(T)), |
| ], |
| returnType: voidNone, |
| ), |
| functionTypeStar( |
| typeFormals: [U, V], |
| parameters: [ |
| requiredParameter(type: typeParameterTypeNone(U)), |
| requiredParameter(type: typeParameterTypeNone(V)), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'void Function<S extends Object*, T extends void>(S, T)*', |
| strT1: 'void Function<U extends dynamic, V extends Object*>(U, V)*', |
| ); |
| } |
| |
| test_top_02() { |
| var T0 = typeParameter('T0', bound: dynamicNone); |
| var T1 = typeParameter('T1', bound: objectStar); |
| |
| var f = functionTypeStar( |
| typeFormals: [T0], |
| returnType: typeParameterTypeNone(T0), |
| ); |
| |
| var g = functionTypeStar( |
| typeFormals: [T1], |
| returnType: typeParameterTypeStar(T1), |
| ); |
| |
| isSubtype( |
| f, |
| g, |
| strT0: 'T0 Function<T0 extends dynamic>()*', |
| strT1: 'T1* Function<T1 extends Object*>()*', |
| ); |
| |
| isSubtype( |
| g, |
| f, |
| strT0: 'T1* Function<T1 extends Object*>()*', |
| strT1: 'T0 Function<T0 extends dynamic>()*', |
| ); |
| } |
| |
| test_top_03() { |
| var T0 = typeParameter('T0', bound: dynamicNone); |
| var T1 = typeParameter('T1', bound: objectStar); |
| var T2 = typeParameter('T2', bound: voidNone); |
| |
| var h = functionTypeStar( |
| typeFormals: [T0], |
| returnType: typeParameterTypeStar(T0), |
| ); |
| |
| var i = functionTypeStar( |
| typeFormals: [T1], |
| returnType: typeParameterTypeStar(T1), |
| ); |
| |
| var j = functionTypeStar( |
| typeFormals: [T2], |
| returnType: typeParameterTypeStar(T2), |
| ); |
| |
| isSubtype(h, i); |
| isSubtype(h, j); |
| isSubtype(i, h); |
| isSubtype(i, j); |
| isSubtype(j, h); |
| isSubtype(h, i); |
| } |
| |
| test_top_04() { |
| isNotSubtype( |
| dynamicNone, |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| strT0: 'dynamic', |
| strT1: 'dynamic Function()*', |
| ); |
| } |
| |
| test_top_05() { |
| isNotSubtype( |
| futureOrStar( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'FutureOr<void Function()*>*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_top_06() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'T, T & void Function()*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_top_07() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| returnType: dynamicNone, |
| ), |
| strT0: 'T, T & void Function()*', |
| strT1: 'dynamic Function()*', |
| ); |
| } |
| |
| test_top_08() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| returnType: objectStar, |
| ), |
| strT0: 'T, T & void Function()*', |
| strT1: 'Object* Function()*', |
| ); |
| } |
| |
| test_top_09() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'void Function(void)*', |
| ); |
| } |
| |
| test_top_10() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: dynamicNone), |
| ], |
| returnType: dynamicNone, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'dynamic Function(dynamic)*', |
| ); |
| } |
| |
| test_top_11() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: objectStar), |
| ], |
| returnType: objectStar, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'Object* Function(Object*)*', |
| ); |
| } |
| |
| test_top_12() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: iterableStar(intStar)), |
| ], |
| returnType: dynamicNone, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'dynamic Function(Iterable<int*>*)*', |
| ); |
| } |
| |
| test_top_13() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: objectStar, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'Object* Function(int*)*', |
| ); |
| } |
| |
| test_top_14() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: voidNone), |
| ], |
| returnType: voidNone, |
| ), |
| ), |
| functionTypeStar( |
| parameters: [ |
| requiredParameter(type: intStar), |
| ], |
| returnType: intStar, |
| ), |
| strT0: 'T, T & void Function(void)*', |
| strT1: 'int* Function(int*)*', |
| ); |
| } |
| |
| test_top_15() { |
| var T = typeParameter( |
| 'T', |
| bound: functionTypeStar( |
| returnType: voidNone, |
| ), |
| ); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'T*, T extends void Function()*', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_top_16() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'T', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_top_17() { |
| isNotSubtype( |
| voidNone, |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| strT0: 'void', |
| strT1: 'void Function()*', |
| ); |
| } |
| |
| test_top_18() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| dynamicNone, |
| typeParameterTypeNone(T), |
| strT0: 'dynamic', |
| strT1: 'T', |
| ); |
| } |
| |
| test_top_19() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| iterableStar( |
| typeParameterTypeNone(T), |
| ), |
| typeParameterTypeNone(T), |
| strT0: 'Iterable<T>*', |
| strT1: 'T', |
| ); |
| } |
| |
| test_top_21() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| functionTypeStar( |
| returnType: voidNone, |
| ), |
| typeParameterTypeNone(T), |
| strT0: 'void Function()*', |
| strT1: 'T', |
| ); |
| } |
| |
| test_top_22() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| futureOrStar( |
| typeParameterTypeNone(T), |
| ), |
| typeParameterTypeNone(T), |
| strT0: 'FutureOr<T>*', |
| strT1: 'T', |
| ); |
| } |
| |
| test_top_23() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| voidNone, |
| typeParameterTypeNone(T), |
| strT0: 'void', |
| strT1: 'T', |
| ); |
| } |
| |
| test_top_24() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| voidNone, |
| promotedTypeParameterTypeNone(T, voidNone), |
| strT0: 'void', |
| strT1: 'T, T & void', |
| ); |
| } |
| |
| test_top_25() { |
| var T = typeParameter('T', bound: voidNone); |
| |
| isNotSubtype( |
| voidNone, |
| promotedTypeParameterTypeNone(T, voidNone), |
| strT0: 'void', |
| strT1: 'T, T extends void, T & void', |
| ); |
| } |
| |
| test_typeParameter_01() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intStar), |
| promotedTypeParameterTypeNone(T, intStar), |
| strT0: 'T, T & int*', |
| strT1: 'T, T & int*', |
| ); |
| } |
| |
| test_typeParameter_02() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intStar), |
| promotedTypeParameterTypeNone(T, numStar), |
| strT0: 'T, T & int*', |
| strT1: 'T, T & num*', |
| ); |
| } |
| |
| test_typeParameter_03() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, numStar), |
| promotedTypeParameterTypeNone(T, numStar), |
| strT0: 'T, T & num*', |
| strT1: 'T, T & num*', |
| ); |
| } |
| |
| test_typeParameter_04() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, numStar), |
| promotedTypeParameterTypeNone(T, intStar), |
| strT0: 'T, T & num*', |
| strT1: 'T, T & int*', |
| ); |
| } |
| |
| test_typeParameter_05() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| nullQuestion, |
| promotedTypeParameterTypeNone(T, numStar), |
| strT0: 'Null?', |
| strT1: 'T, T & num*', |
| ); |
| } |
| |
| test_typeParameter_06() { |
| var T = typeParameter('T', bound: intStar); |
| |
| isSubtype( |
| promotedTypeParameterTypeStar(T, intStar), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends int*, T & int*', |
| strT1: 'T*, T extends int*', |
| ); |
| } |
| |
| test_typeParameter_07() { |
| var T = typeParameter('T', bound: numStar); |
| |
| isSubtype( |
| promotedTypeParameterTypeStar(T, intStar), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends num*, T & int*', |
| strT1: 'T*, T extends num*', |
| ); |
| } |
| |
| test_typeParameter_08() { |
| var T = typeParameter('T', bound: numStar); |
| |
| isSubtype( |
| promotedTypeParameterTypeStar(T, numStar), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends num*, T & num*', |
| strT1: 'T*, T extends num*', |
| ); |
| } |
| |
| test_typeParameter_09() { |
| var T = typeParameter('T', bound: intStar); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| promotedTypeParameterTypeStar(T, intStar), |
| strT0: 'T*, T extends int*', |
| strT1: 'T*, T extends int*, T & int*', |
| ); |
| } |
| |
| test_typeParameter_10() { |
| var T = typeParameter('T', bound: intStar); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| promotedTypeParameterTypeStar(T, numStar), |
| strT0: 'T*, T extends int*', |
| strT1: 'T*, T extends int*, T & num*', |
| ); |
| } |
| |
| test_typeParameter_11() { |
| var T = typeParameter('T', bound: numStar); |
| |
| isNotSubtype( |
| typeParameterTypeStar(T), |
| promotedTypeParameterTypeStar(T, intStar), |
| strT0: 'T*, T extends num*', |
| strT1: 'T*, T extends num*, T & int*', |
| ); |
| } |
| |
| test_typeParameter_12() { |
| var T = typeParameter('T', bound: numStar); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends num*', |
| strT1: 'T*, T extends num*', |
| ); |
| } |
| |
| test_typeParameter_13() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| typeParameterTypeNone(T), |
| strT0: 'T', |
| strT1: 'T', |
| ); |
| } |
| |
| test_typeParameter_14() { |
| var S = typeParameter('S'); |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| typeParameterTypeNone(S), |
| typeParameterTypeNone(T), |
| strT0: 'S', |
| strT1: 'T', |
| ); |
| } |
| |
| test_typeParameter_15() { |
| var T = typeParameter('T', bound: objectStar); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends Object*', |
| strT1: 'T*, T extends Object*', |
| ); |
| } |
| |
| test_typeParameter_16() { |
| var S = typeParameter('S', bound: objectStar); |
| var T = typeParameter('T', bound: objectStar); |
| |
| isNotSubtype( |
| typeParameterTypeNone(S), |
| typeParameterTypeNone(T), |
| strT0: 'S, S extends Object*', |
| strT1: 'T, T extends Object*', |
| ); |
| } |
| |
| test_typeParameter_17() { |
| var T = typeParameter('T', bound: dynamicNone); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| typeParameterTypeStar(T), |
| strT0: 'T*, T extends dynamic', |
| strT1: 'T*, T extends dynamic', |
| ); |
| } |
| |
| test_typeParameter_18() { |
| var S = typeParameter('S', bound: dynamicNone); |
| var T = typeParameter('T', bound: dynamicNone); |
| |
| isNotSubtype( |
| typeParameterTypeNone(S), |
| typeParameterTypeNone(T), |
| strT0: 'S, S extends dynamic', |
| strT1: 'T, T extends dynamic', |
| ); |
| } |
| |
| test_typeParameter_19() { |
| var S = typeParameter('S'); |
| var T = typeParameter('T', bound: typeParameterTypeNone(S)); |
| |
| isNotSubtype( |
| typeParameterTypeNone(S), |
| typeParameterTypeNone(T), |
| strT0: 'S', |
| strT1: 'T, T extends S', |
| ); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| typeParameterTypeNone(S), |
| strT0: 'T, T extends S', |
| strT1: 'S', |
| ); |
| } |
| |
| test_typeParameter_20() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intStar), |
| intStar, |
| strT0: 'T, T & int*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_typeParameter_21() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, intStar), |
| numStar, |
| strT0: 'T, T & int*', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_typeParameter_22() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| promotedTypeParameterTypeNone(T, numStar), |
| numStar, |
| strT0: 'T, T & num*', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_typeParameter_23() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(T, numStar), |
| intStar, |
| strT0: 'T, T & num*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_typeParameter_24() { |
| var S = typeParameter('S'); |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(S, numStar), |
| typeParameterTypeNone(T), |
| strT0: 'S, S & num*', |
| strT1: 'T', |
| ); |
| } |
| |
| test_typeParameter_25() { |
| var S = typeParameter('S'); |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| promotedTypeParameterTypeNone(S, numStar), |
| promotedTypeParameterTypeNone(T, numStar), |
| strT0: 'S, S & num*', |
| strT1: 'T, T & num*', |
| ); |
| } |
| |
| test_typeParameter_26() { |
| var S = typeParameter('S', bound: intStar); |
| |
| isSubtype( |
| typeParameterTypeStar(S), |
| intStar, |
| strT0: 'S*, S extends int*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_typeParameter_27() { |
| var S = typeParameter('S', bound: intStar); |
| |
| isSubtype( |
| typeParameterTypeStar(S), |
| numStar, |
| strT0: 'S*, S extends int*', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_typeParameter_28() { |
| var S = typeParameter('S', bound: numStar); |
| |
| isSubtype( |
| typeParameterTypeStar(S), |
| numStar, |
| strT0: 'S*, S extends num*', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_typeParameter_29() { |
| var S = typeParameter('S', bound: numStar); |
| |
| isNotSubtype( |
| typeParameterTypeStar(S), |
| intStar, |
| strT0: 'S*, S extends num*', |
| strT1: 'int*', |
| ); |
| } |
| |
| test_typeParameter_30() { |
| var S = typeParameter('S', bound: numStar); |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| typeParameterTypeStar(S), |
| typeParameterTypeNone(T), |
| strT0: 'S*, S extends num*', |
| strT1: 'T', |
| ); |
| } |
| |
| test_typeParameter_31() { |
| var S = typeParameter('S', bound: numStar); |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| typeParameterTypeStar(S), |
| promotedTypeParameterTypeNone(T, numStar), |
| strT0: 'S*, S extends num*', |
| strT1: 'T, T & num*', |
| ); |
| } |
| |
| test_typeParameter_32() { |
| var T = typeParameter('T', bound: dynamicNone); |
| |
| isNotSubtype( |
| dynamicNone, |
| promotedTypeParameterTypeNone(T, dynamicNone), |
| strT0: 'dynamic', |
| strT1: 'T, T extends dynamic, T & dynamic', |
| ); |
| } |
| |
| test_typeParameter_33() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| functionTypeStar( |
| returnType: typeParameterTypeNone(T), |
| ), |
| promotedTypeParameterTypeNone( |
| T, |
| functionTypeStar( |
| returnType: typeParameterTypeNone(T), |
| ), |
| ), |
| strT0: 'T Function()*', |
| strT1: 'T, T & T Function()*', |
| ); |
| } |
| |
| test_typeParameter_34() { |
| var T = typeParameter('T'); |
| |
| isNotSubtype( |
| futureOrStar( |
| promotedTypeParameterTypeNone(T, stringStar), |
| ), |
| promotedTypeParameterTypeNone(T, stringStar), |
| strT0: 'FutureOr<T>*, T & String*', |
| strT1: 'T, T & String*', |
| ); |
| } |
| |
| test_typeParameter_35() { |
| var T = typeParameter('T'); |
| |
| isSubtype( |
| nullStar, |
| typeParameterTypeStar(T), |
| strT0: 'Null*', |
| strT1: 'T*', |
| ); |
| } |
| |
| test_typeParameter_36() { |
| var T = typeParameter('T', bound: numNone); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| numNone, |
| strT0: 'T, T extends num', |
| strT1: 'num', |
| ); |
| } |
| |
| test_typeParameter_37() { |
| var T = typeParameter('T', bound: objectQuestion); |
| |
| var type = promotedTypeParameterTypeNone(T, numQuestion); |
| |
| isNotSubtype( |
| type, |
| numNone, |
| strT0: 'T, T extends Object?, T & num?', |
| strT1: 'num', |
| ); |
| isSubtype( |
| type, |
| numQuestion, |
| strT0: 'T, T extends Object?, T & num?', |
| strT1: 'num?', |
| ); |
| isSubtype( |
| type, |
| numStar, |
| strT0: 'T, T extends Object?, T & num?', |
| strT1: 'num*', |
| ); |
| } |
| |
| test_typeParameter_38() { |
| var T = typeParameter('T', bound: numStar); |
| |
| isSubtype( |
| typeParameterTypeStar(T), |
| objectNone, |
| strT0: 'T*, T extends num*', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_typeParameter_39() { |
| var T = typeParameter('T', bound: numNone); |
| |
| isSubtype( |
| typeParameterTypeNone(T), |
| objectNone, |
| strT0: 'T, T extends num', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_typeParameter_40() { |
| var T = typeParameter('T', bound: numNone); |
| |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| objectNone, |
| strT0: 'T?, T extends num', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_typeParameter_41() { |
| var T = typeParameter('T', bound: numQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeNone(T), |
| objectNone, |
| strT0: 'T, T extends num?', |
| strT1: 'Object', |
| ); |
| } |
| |
| test_typeParameter_42() { |
| var T = typeParameter('T', bound: numQuestion); |
| |
| isNotSubtype( |
| typeParameterTypeQuestion(T), |
| objectNone, |
| strT0: 'T?, T extends num?', |
| strT1: 'Object', |
| ); |
| } |
| |
| void _defineType(String str, DartType type) { |
| for (var key in _types.keys) { |
| if (key == 'Never' || _typeStr(type) == 'Never') { |
| // We have aliases for Never. |
| } else { |
| var value = _types[key]; |
| if (key == str) { |
| fail('Duplicate type: $str; existing: $value; new: $type'); |
| } |
| if (_typeStr(value) == _typeStr(type)) { |
| fail('Duplicate type: $str'); |
| } |
| } |
| } |
| _types[str] = type; |
| } |
| |
| void _defineTypes() { |
| _defineType('dynamic', dynamicNone); |
| _defineType('void', voidNone); |
| |
| _defineType('Never', neverNone); |
| _defineType('Never*', neverStar); |
| _defineType('Never?', neverQuestion); |
| |
| _defineType('Null?', nullQuestion); |
| |
| _defineType('Object', objectNone); |
| _defineType('Object*', objectStar); |
| _defineType('Object?', objectQuestion); |
| |
| _defineType('Comparable<Object*>*', comparableStar(objectStar)); |
| _defineType('Comparable<num*>*', comparableStar(numStar)); |
| _defineType('Comparable<int*>*', comparableStar(intStar)); |
| |
| _defineType('num', numNone); |
| _defineType('num*', numStar); |
| _defineType('num?', numQuestion); |
| |
| _defineType('int', intNone); |
| _defineType('int*', intStar); |
| _defineType('int?', intQuestion); |
| |
| _defineType('double', doubleNone); |
| _defineType('double*', doubleStar); |
| _defineType('double?', doubleQuestion); |
| |
| _defineType('List<Object*>*', listStar(objectStar)); |
| _defineType('List<num*>*', listStar(numStar)); |
| _defineType('List<int>', listNone(intNone)); |
| _defineType('List<int>*', listStar(intNone)); |
| _defineType('List<int>?', listQuestion(intNone)); |
| _defineType('List<int*>', listNone(intStar)); |
| _defineType('List<int*>*', listStar(intStar)); |
| _defineType('List<int*>?', listQuestion(intStar)); |
| _defineType('List<int?>', listNone(intQuestion)); |
| |
| _defineType( |
| 'List<Comparable<Object*>*>*', |
| listStar( |
| comparableStar(objectStar), |
| ), |
| ); |
| _defineType( |
| 'List<Comparable<num*>*>*', |
| listStar( |
| comparableStar(numStar), |
| ), |
| ); |
| _defineType( |
| 'List<Comparable<Comparable<num*>*>*>*', |
| listStar( |
| comparableStar( |
| comparableStar(numStar), |
| ), |
| ), |
| ); |
| |
| _defineType('Iterable<Object*>*', iterableStar(objectStar)); |
| _defineType('Iterable<int*>*', iterableStar(intStar)); |
| _defineType('Iterable<num*>*', iterableStar(numStar)); |
| |
| _defineType('Function', functionNone); |
| _defineType('Function*', functionStar); |
| _defineType('Function?', functionQuestion); |
| |
| _defineType('FutureOr<Object*>*', futureOrStar(objectStar)); |
| _defineType('FutureOr<num*>*', futureOrStar(numStar)); |
| _defineType('FutureOr<int*>*', futureOrStar(intStar)); |
| _defineType('FutureOr<num?>?', futureOrQuestion(numQuestion)); |
| |
| _defineType('FutureOr<Object>', futureOrNone(objectNone)); |
| _defineType('FutureOr<Object>?', futureOrQuestion(objectNone)); |
| _defineType('FutureOr<Object?>', futureOrNone(objectQuestion)); |
| _defineType('FutureOr<Object?>?', futureOrQuestion(objectQuestion)); |
| |
| _defineType('Future<num>', futureNone(numNone)); |
| _defineType('Future<num>?', futureQuestion(numNone)); |
| _defineType('Future<num?>', futureNone(numQuestion)); |
| _defineType('Future<num?>?', futureQuestion(numQuestion)); |
| |
| _defineType('FutureOr<int>', futureOrNone(intNone)); |
| _defineType('FutureOr<int>?', futureOrQuestion(intNone)); |
| _defineType('FutureOr<int?>', futureOrNone(intQuestion)); |
| _defineType('FutureOr<int?>?', futureOrQuestion(intQuestion)); |
| |
| _defineType('FutureOr<int>*', futureOrStar(intNone)); |
| _defineType('FutureOr<int*>', futureOrNone(intStar)); |
| _defineType('Future<int*>*', futureStar(intStar)); |
| |
| _defineType('FutureOr<num>', futureOrNone(numNone)); |
| _defineType('FutureOr<num>*', futureOrStar(numNone)); |
| _defineType('FutureOr<num>?', futureOrQuestion(numNone)); |
| |
| _defineType('FutureOr<num*>', futureOrNone(numStar)); |
| _defineType('FutureOr<num?>', futureOrNone(numQuestion)); |
| |
| _defineType('Future<Object>', futureNone(objectNone)); |
| _defineType( |
| 'FutureOr<Future<Object>>', |
| futureOrNone( |
| futureNone(objectNone), |
| ), |
| ); |
| _defineType( |
| 'FutureOr<Future<Object>>?', |
| futureOrQuestion( |
| futureNone(objectNone), |
| ), |
| ); |
| _defineType( |
| 'FutureOr<Future<Object>?>', |
| futureOrNone( |
| futureQuestion(objectNone), |
| ), |
| ); |
| _defineType( |
| 'FutureOr<Future<Object>?>?', |
| futureOrQuestion( |
| futureQuestion(objectNone), |
| ), |
| ); |
| |
| _defineType( |
| 'Future<Future<num>>?', |
| futureQuestion( |
| futureNone(numNone), |
| ), |
| ); |
| _defineType( |
| 'Future<Future<num?>?>?', |
| futureQuestion( |
| futureQuestion(numQuestion), |
| ), |
| ); |
| |
| _defineType( |
| 'Future<Future<Future<num>>>?', |
| futureQuestion( |
| futureNone( |
| futureNone(numNone), |
| ), |
| ), |
| ); |
| _defineType( |
| 'Future<Future<Future<num?>?>?>?', |
| futureQuestion( |
| futureQuestion( |
| futureQuestion(numQuestion), |
| ), |
| ), |
| ); |
| |
| _defineType( |
| 'FutureOr<FutureOr<FutureOr<num>>?>', |
| futureOrNone( |
| futureOrQuestion( |
| futureOrNone(numNone), |
| ), |
| ), |
| ); |
| _defineType( |
| 'FutureOr<FutureOr<FutureOr<num?>>>', |
| futureOrNone( |
| futureOrNone( |
| futureOrNone(numQuestion), |
| ), |
| ), |
| ); |
| |
| _defineType( |
| 'int* Function()', |
| functionTypeNone( |
| returnType: intStar, |
| ), |
| ); |
| _defineType( |
| 'int* Function()*', |
| functionTypeStar( |
| returnType: intStar, |
| ), |
| ); |
| _defineType( |
| 'int* Function()?', |
| functionTypeQuestion( |
| returnType: intStar, |
| ), |
| ); |
| |
| _defineType( |
| 'num Function(num)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: numNone)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num Function(num)?', |
| functionTypeQuestion( |
| parameters: [requiredParameter(type: numNone)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num Function(num)*', |
| functionTypeStar( |
| parameters: [requiredParameter(type: numNone)], |
| returnType: numNone, |
| ), |
| ); |
| |
| _defineType( |
| 'num* Function(num*)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: numStar)], |
| returnType: numStar, |
| ), |
| ); |
| _defineType( |
| 'num* Function(num*)*', |
| functionTypeStar( |
| parameters: [requiredParameter(type: numStar)], |
| returnType: numStar, |
| ), |
| ); |
| _defineType( |
| 'num* Function(num*)?', |
| functionTypeQuestion( |
| parameters: [requiredParameter(type: numStar)], |
| returnType: numStar, |
| ), |
| ); |
| |
| _defineType( |
| 'int* Function(num*)*', |
| functionTypeStar( |
| parameters: [requiredParameter(type: numStar)], |
| returnType: intStar, |
| ), |
| ); |
| |
| _defineType( |
| 'num* Function(int*)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: intStar)], |
| returnType: numStar, |
| ), |
| ); |
| _defineType( |
| 'num* Function(int*)*', |
| functionTypeStar( |
| parameters: [requiredParameter(type: intStar)], |
| returnType: numStar, |
| ), |
| ); |
| _defineType( |
| 'num* Function(int*)?', |
| functionTypeQuestion( |
| parameters: [requiredParameter(type: intStar)], |
| returnType: numStar, |
| ), |
| ); |
| |
| _defineType( |
| 'int* Function(int*)*', |
| functionTypeStar( |
| parameters: [requiredParameter(type: intStar)], |
| returnType: intStar, |
| ), |
| ); |
| |
| _defineType( |
| 'num Function(num?)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: numQuestion)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num? Function(num)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: numNone)], |
| returnType: numQuestion, |
| ), |
| ); |
| _defineType( |
| 'num? Function(num?)', |
| functionTypeNone( |
| parameters: [requiredParameter(type: numQuestion)], |
| returnType: numQuestion, |
| ), |
| ); |
| |
| _defineType( |
| 'num Function({num x})', |
| functionTypeNone( |
| parameters: [namedParameter(name: 'x', type: numNone)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num Function({num? x})', |
| functionTypeNone( |
| parameters: [namedParameter(name: 'x', type: numQuestion)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num? Function({num x})', |
| functionTypeNone( |
| parameters: [namedParameter(name: 'x', type: numNone)], |
| returnType: numQuestion, |
| ), |
| ); |
| _defineType( |
| 'num? Function({num? x})', |
| functionTypeNone( |
| parameters: [namedParameter(name: 'x', type: numQuestion)], |
| returnType: numQuestion, |
| ), |
| ); |
| |
| _defineType( |
| 'num Function([num])', |
| functionTypeNone( |
| parameters: [positionalParameter(type: numNone)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num Function([num?])', |
| functionTypeNone( |
| parameters: [positionalParameter(type: numQuestion)], |
| returnType: numNone, |
| ), |
| ); |
| _defineType( |
| 'num? Function([num])', |
| functionTypeNone( |
| parameters: [positionalParameter(type: numNone)], |
| returnType: numQuestion, |
| ), |
| ); |
| _defineType( |
| 'num? Function([num?])', |
| functionTypeNone( |
| parameters: [positionalParameter(type: numQuestion)], |
| returnType: numQuestion, |
| ), |
| ); |
| } |
| |
| DartType _getTypeByStr(String str) { |
| var type = _types[str]; |
| expect(type, isNotNull, reason: 'No DartType for: $str'); |
| return type; |
| } |
| |
| String _typeParametersStr(TypeImpl type) { |
| var typeStr = ''; |
| |
| var typeParameterCollector = _TypeParameterCollector(); |
| DartTypeVisitor.visit(type, typeParameterCollector); |
| for (var typeParameter in typeParameterCollector.typeParameters) { |
| typeStr += ', $typeParameter'; |
| } |
| return typeStr; |
| } |
| |
| static String _typeStr(DartType type) { |
| return type.getDisplayString(withNullability: true); |
| } |
| } |
| |
| @reflectiveTest |
| class SubtypingCompoundTest extends _SubtypingCompoundTestBase { |
| test_bottom_isBottom() { |
| var equivalents = <DartType>[neverStar]; |
| |
| var supertypes = <DartType>[ |
| dynamicNone, |
| objectStar, |
| intStar, |
| doubleStar, |
| numStar, |
| stringStar, |
| functionStar, |
| ]; |
| |
| _checkGroups( |
| neverStar, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| ); |
| } |
| |
| test_double() { |
| var equivalents = <DartType>[doubleStar]; |
| var supertypes = <DartType>[numStar]; |
| var unrelated = <DartType>[intStar]; |
| _checkGroups( |
| doubleStar, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| ); |
| } |
| |
| test_dynamic_isTop() { |
| var equivalents = <DartType>[ |
| dynamicNone, |
| objectStar, |
| voidNone, |
| ]; |
| |
| var subtypes = <DartType>[ |
| intStar, |
| doubleStar, |
| numStar, |
| stringStar, |
| functionStar, |
| neverStar, |
| ]; |
| |
| _checkGroups( |
| dynamicType, |
| equivalents: equivalents, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_int() { |
| var equivalents = <DartType>[intStar]; |
| var supertypes = <DartType>[numStar]; |
| var unrelated = <DartType>[doubleStar]; |
| _checkGroups( |
| intStar, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| ); |
| } |
| |
| test_num() { |
| var equivalents = <DartType>[numStar]; |
| var supertypes = <DartType>[objectStar]; |
| var unrelated = <DartType>[stringStar]; |
| var subtypes = <DartType>[intStar, doubleStar]; |
| _checkGroups( |
| numStar, |
| equivalents: equivalents, |
| supertypes: supertypes, |
| unrelated: unrelated, |
| subtypes: subtypes, |
| ); |
| } |
| |
| test_void_isTop() { |
| var equivalents = <DartType>[ |
| dynamicNone, |
| objectStar, |
| voidNone, |
| ]; |
| |
| var subtypes = <DartType>[ |
| intStar, |
| doubleStar, |
| numStar, |
| stringStar, |
| functionStar, |
| neverStar, |
| ]; |
| |
| _checkGroups( |
| voidNone, |
| equivalents: equivalents, |
| subtypes: subtypes, |
| ); |
| } |
| } |
| |
| class _SubtypingCompoundTestBase extends _SubtypingTestBase { |
| void _checkEquivalent(DartType type1, DartType type2) { |
| _checkIsSubtypeOf(type1, type2); |
| _checkIsSubtypeOf(type2, type1); |
| } |
| |
| void _checkGroups(DartType t1, |
| {List<DartType> equivalents, |
| List<DartType> unrelated, |
| List<DartType> subtypes, |
| List<DartType> supertypes}) { |
| if (equivalents != null) { |
| for (DartType t2 in equivalents) { |
| _checkEquivalent(t1, t2); |
| } |
| } |
| if (unrelated != null) { |
| for (DartType t2 in unrelated) { |
| _checkUnrelated(t1, t2); |
| } |
| } |
| if (subtypes != null) { |
| for (DartType t2 in subtypes) { |
| _checkIsStrictSubtypeOf(t2, t1); |
| } |
| } |
| if (supertypes != null) { |
| for (DartType t2 in supertypes) { |
| _checkIsStrictSubtypeOf(t1, t2); |
| } |
| } |
| } |
| |
| void _checkIsNotSubtypeOf(DartType type1, DartType type2) { |
| var strType1 = _typeStr(type1); |
| var strType2 = _typeStr(type2); |
| expect(typeSystem.isSubtypeOf2(type1, type2), false, |
| reason: '$strType1 was not supposed to be a subtype of $strType2'); |
| } |
| |
| void _checkIsStrictSubtypeOf(DartType type1, DartType type2) { |
| _checkIsSubtypeOf(type1, type2); |
| _checkIsNotSubtypeOf(type2, type1); |
| } |
| |
| void _checkIsSubtypeOf(DartType type1, DartType type2) { |
| var strType1 = _typeStr(type1); |
| var strType2 = _typeStr(type2); |
| expect(typeSystem.isSubtypeOf2(type1, type2), true, |
| reason: '$strType1 is not a subtype of $strType2'); |
| } |
| |
| void _checkUnrelated(DartType type1, DartType type2) { |
| _checkIsNotSubtypeOf(type1, type2); |
| _checkIsNotSubtypeOf(type2, type1); |
| } |
| |
| static String _typeStr(DartType type) { |
| return type.getDisplayString(withNullability: true); |
| } |
| } |
| |
| class _SubtypingTestBase extends AbstractTypeSystemNullSafetyTest {} |
| |
| class _TypeParameterCollector extends DartTypeVisitor<void> { |
| final Set<String> typeParameters = {}; |
| |
| /// We don't need to print bounds for these type parameters, because |
| /// they are already included into the function type itself, and cannot |
| /// be promoted. |
| final Set<TypeParameterElement> functionTypeParameters = {}; |
| |
| @override |
| void defaultDartType(DartType type) { |
| throw UnimplementedError('(${type.runtimeType}) $type'); |
| } |
| |
| @override |
| void visitDynamicType(DynamicTypeImpl type) {} |
| |
| @override |
| void visitFunctionType(FunctionType type) { |
| functionTypeParameters.addAll(type.typeFormals); |
| for (var typeParameter in type.typeFormals) { |
| var bound = typeParameter.bound; |
| if (bound != null) { |
| DartTypeVisitor.visit(bound, this); |
| } |
| } |
| for (var parameter in type.parameters) { |
| DartTypeVisitor.visit(parameter.type, this); |
| } |
| DartTypeVisitor.visit(type.returnType, this); |
| } |
| |
| @override |
| void visitInterfaceType(InterfaceType type) { |
| for (var typeArgument in type.typeArguments) { |
| DartTypeVisitor.visit(typeArgument, this); |
| } |
| } |
| |
| @override |
| void visitNeverType(NeverTypeImpl type) {} |
| |
| @override |
| void visitTypeParameterType(TypeParameterType type) { |
| if (!functionTypeParameters.contains(type.element)) { |
| var bound = type.element.bound; |
| var promotedBound = (type as TypeParameterTypeImpl).promotedBound; |
| |
| if (bound == null && promotedBound == null) { |
| return; |
| } |
| |
| var str = ''; |
| |
| if (bound != null) { |
| var boundStr = bound.getDisplayString(withNullability: true); |
| str += '${type.element.name} extends ' + boundStr; |
| } |
| |
| if (promotedBound != null) { |
| var promotedBoundStr = promotedBound.getDisplayString( |
| withNullability: true, |
| ); |
| if (str.isNotEmpty) { |
| str += ', '; |
| } |
| str += '${type.element.name} & ' + promotedBoundStr; |
| } |
| |
| typeParameters.add(str); |
| } |
| } |
| |
| @override |
| void visitVoidType(VoidType type) {} |
| } |