| // Copyright (c) 2017, 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. |
| |
| // @dart = 2.7 |
| |
| import 'package:async_helper/async_helper.dart'; |
| import 'package:compiler/src/commandline_options.dart'; |
| import 'package:compiler/src/elements/entities.dart'; |
| import 'package:compiler/src/elements/types.dart'; |
| import 'package:expect/expect.dart'; |
| import '../helpers/type_test_helper.dart'; |
| |
| const List<FunctionTypeData> existentialTypeData = const <FunctionTypeData>[ |
| const FunctionTypeData('void', 'F1', '<T>(T t)'), |
| const FunctionTypeData('void', 'F2', '<S>(S s)'), |
| const FunctionTypeData('void', 'F3', '<U, V>(U u, V v)'), |
| const FunctionTypeData('void', 'F4', '<U, V>(V v, U u)'), |
| const FunctionTypeData('void', 'F5', '<W extends num>(W w)'), |
| const FunctionTypeData('void', 'F6', '<X extends int>(X x)'), |
| const FunctionTypeData('void', 'F7', '<Y extends num>(Y y, [int i])'), |
| const FunctionTypeData('Z', 'F8', '<Z extends num>(Z z)'), |
| const FunctionTypeData('T', 'F13', '<T>(T t1, T t2)'), |
| const FunctionTypeData('S', 'F14', '<S>(S s1, S s2)'), |
| ]; |
| |
| class ToStringTestData { |
| final DartType type; |
| final String expected; |
| |
| const ToStringTestData(this.type, this.expected); |
| } |
| |
| class InstantiateTestData { |
| final DartType type; |
| final List<DartType> instantiation; |
| final String expected; |
| |
| const InstantiateTestData(this.type, this.instantiation, this.expected); |
| } |
| |
| class SubstTestData { |
| final List<DartType> arguments; |
| final List<DartType> parameters; |
| final DartType type; |
| final String expected; |
| |
| const SubstTestData( |
| this.arguments, this.parameters, this.type, this.expected); |
| } |
| |
| main() { |
| asyncTest(() async { |
| var env = await TypeEnvironment.create( |
| createTypedefs(existentialTypeData, additionalData: """ |
| class C1 {} |
| class C2 {} |
| class C3<T> { |
| factory C3.fact() => C3.gen(); |
| C3.gen(); |
| } |
| class C4 implements C3<C4> {} |
| void F9<U extends V, V>(U u, V v) {} |
| F10() { |
| void local<A extends B, B>(A a, B b) {} |
| } |
| void F11<Q extends C3<Q>>(Q q) {} |
| void F12<P extends C3<P>>(P p) {} |
| class C5<T> { |
| Map<T,A> F15<A extends B, B extends T>(A a, B b) => null; |
| Map<T,A> F16<A extends T, B extends A>(A a, B b) => null; |
| T F17<A extends List<B>, B extends Map<T,A>>(A a, B b, T t) => null; |
| T F18<P extends T>( |
| [Q Function<Q extends P>(P, Q, T) f1, |
| X Function<X extends P>(P, X, T) f2]) => null; |
| } |
| |
| main() { |
| ${createUses(existentialTypeData)} |
| |
| new C1(); |
| new C2(); |
| new C3.fact(); |
| new C4(); |
| |
| F9(null, null); |
| F10(); |
| F11(null); |
| F12(null); |
| new C5<num>().F15<int, int>(1, 2); |
| new C5<num>().F16<int, int>(1, 2); |
| new C5<num>().F17(null, null, null); |
| new C5<num>().F18(); |
| } |
| """), |
| options: [Flags.noSoundNullSafety, Flags.printLegacyStars]); |
| |
| var types = env.types; |
| |
| testToString(DartType type, String expected) { |
| Expect.equals(expected, env.printType(type)); |
| } |
| |
| testBounds(DartType type, List<DartType> expectedBounds) { |
| FunctionType functionType = type.withoutNullabilityAs<FunctionType>(); |
| Expect.equals(expectedBounds.length, functionType.typeVariables.length, |
| "Unexpected type variable count in ${env.printType(type)}."); |
| for (int i = 0; i < expectedBounds.length; i++) { |
| Expect.equals( |
| env.legacyWrap(expectedBounds[i]), |
| functionType.typeVariables[i].bound, |
| "Unexpected ${i}th bound in ${env.printType(type)}."); |
| } |
| } |
| |
| testInstantiate( |
| DartType type, List<DartType> instantiation, String expectedToString) { |
| DartType result = types.instantiate( |
| type.withoutNullabilityAs<FunctionType>(), instantiation); |
| String resultString = env.printType(result); |
| Expect.equals( |
| expectedToString, |
| resultString, |
| "Unexpected instantiation of ${env.printType(type)} with $instantiation: " |
| "$resultString"); |
| } |
| |
| void testSubst(List<DartType> arguments, List<DartType> parameters, |
| DartType type1, String expectedToString) { |
| DartType subst = types.subst(arguments, parameters, type1); |
| Expect.equals(expectedToString, env.printType(subst), |
| "${env.printType(type1)}.subst(${env.printTypes(arguments)},${env.printTypes(parameters)})"); |
| } |
| |
| testRelations(DartType a, DartType b, |
| {bool areEqual: false, bool isSubtype: false}) { |
| if (areEqual) { |
| isSubtype = true; |
| } |
| String aString = env.printType(a); |
| String bString = env.printType(b); |
| Expect.equals( |
| areEqual, |
| a == b, |
| "Expected `$aString` and `$bString` to be " |
| "${areEqual ? 'equal' : 'non-equal'}, but they are not."); |
| Expect.equals( |
| isSubtype, |
| env.isSubtype(a, b), |
| "Expected `$aString` ${isSubtype ? '' : 'not '}to be a subtype of " |
| "`$bString`, but it is${isSubtype ? ' not' : ''}."); |
| if (isSubtype) { |
| Expect.isTrue(env.isPotentialSubtype(a, b), |
| '$aString <: $bString but not a potential subtype.'); |
| } |
| } |
| |
| InterfaceType Object_ = env['Object']; |
| InterfaceType num_ = env['num']; |
| InterfaceType int_ = env['int']; |
| InterfaceType C1 = env.instantiate(env.getClass('C1'), []); |
| InterfaceType C2 = env.instantiate(env.getClass('C2'), []); |
| ClassEntity C3 = env.getClass('C3'); |
| InterfaceType C4 = env.instantiate(env.getClass('C4'), []); |
| DartType F1 = env.getFieldType('F1'); |
| DartType F2 = env.getFieldType('F2'); |
| DartType F3 = env.getFieldType('F3'); |
| DartType F4 = env.getFieldType('F4'); |
| DartType F5 = env.getFieldType('F5'); |
| DartType F6 = env.getFieldType('F6'); |
| DartType F7 = env.getFieldType('F7'); |
| DartType F8 = env.getFieldType('F8'); |
| FunctionType F9 = env.getMemberType('F9'); |
| FunctionType F10 = env.getClosureType('F10'); |
| FunctionType F11 = env.getMemberType('F11'); |
| FunctionType F12 = env.getMemberType('F12'); |
| DartType F13 = env.getFieldType('F13'); |
| DartType F14 = env.getFieldType('F14'); |
| ClassEntity C5 = env.getClass('C5'); |
| TypeVariableType C5_T = |
| (env.getElementType('C5') as InterfaceType).typeArguments.single; |
| FunctionType F15 = env.getMemberType('F15', C5); |
| FunctionType F16 = env.getMemberType('F16', C5); |
| FunctionType F17 = env.getMemberType('F17', C5); |
| FunctionType F18 = env.getMemberType('F18', C5); |
| |
| List<DartType> all = [ |
| F1, |
| F2, |
| F3, |
| F4, |
| F5, |
| F6, |
| F7, |
| F8, |
| F9, |
| F10, |
| F11, |
| F12, |
| F13, |
| F14, |
| F15, |
| F16, |
| F17, |
| F18, |
| ]; |
| |
| all.forEach(print); |
| |
| List<ToStringTestData> toStringExpected = [ |
| ToStringTestData(F1, 'void Function<#A>(#A*)*'), |
| ToStringTestData(F2, 'void Function<#A>(#A*)*'), |
| ToStringTestData(F3, 'void Function<#A,#B>(#A*,#B*)*'), |
| ToStringTestData(F4, 'void Function<#A,#B>(#B*,#A*)*'), |
| ToStringTestData(F5, 'void Function<#A extends num*>(#A*)*'), |
| ToStringTestData(F6, 'void Function<#A extends int*>(#A*)*'), |
| ToStringTestData(F7, 'void Function<#A extends num*>(#A*,[int*])*'), |
| ToStringTestData(F8, '#A* Function<#A extends num*>(#A*)*'), |
| ToStringTestData(F9, 'void Function<#A extends #B*,#B>(#A*,#B*)'), |
| ToStringTestData(F10, 'void Function<#A extends #B*,#B>(#A*,#B*)'), |
| ToStringTestData(F11, 'void Function<#A extends C3<#A*>*>(#A*)'), |
| ToStringTestData(F12, 'void Function<#A extends C3<#A*>*>(#A*)'), |
| ToStringTestData(F13, '#A* Function<#A>(#A*,#A*)*'), |
| ToStringTestData(F14, '#A* Function<#A>(#A*,#A*)*'), |
| ToStringTestData(F15, |
| 'Map<C5.T*,#A*>* Function<#A extends #B*,#B extends C5.T*>(#A*,#B*)'), |
| ToStringTestData(F16, |
| 'Map<C5.T*,#A*>* Function<#A extends C5.T*,#B extends #A*>(#A*,#B*)'), |
| ToStringTestData( |
| F17, |
| 'C5.T* Function<#A extends List<#B*>*,' |
| '#B extends Map<C5.T*,#A*>*>(#A*,#B*,Object*)'), |
| ToStringTestData( |
| F18, |
| 'C5.T* Function<#A extends C5.T*>([' |
| '#A2* Function<#A2 extends #A*>(#A*,#A2*,C5.T*)*,' |
| '#A3* Function<#A3 extends #A*>(#A*,#A3*,C5.T*)*])'), |
| ]; |
| |
| for (var test in toStringExpected) { |
| testToString(test.type, test.expected); |
| } |
| |
| testBounds(F1, [Object_]); |
| testBounds(F2, [Object_]); |
| testBounds(F3, [Object_, Object_]); |
| testBounds(F4, [Object_, Object_]); |
| testBounds(F5, [num_]); |
| testBounds(F6, [int_]); |
| testBounds(F7, [num_]); |
| testBounds(F8, [num_]); |
| testBounds(F9, [F9.typeVariables.last, Object_]); |
| testBounds(F10, [F10.typeVariables.last, Object_]); |
| testBounds(F11, [ |
| env.instantiate(C3, [F11.typeVariables.last]) |
| ]); |
| testBounds(F12, [ |
| env.instantiate(C3, [F12.typeVariables.last]) |
| ]); |
| testBounds(F13, [Object_]); |
| testBounds(F14, [Object_]); |
| |
| List<InstantiateTestData> instantiateExpected = [ |
| InstantiateTestData(F1, [C1], 'void Function(C1*)'), |
| InstantiateTestData(F2, [C2], 'void Function(C2*)'), |
| InstantiateTestData(F3, [C1, C2], 'void Function(C1*,C2*)'), |
| InstantiateTestData(F4, [C1, C2], 'void Function(C2*,C1*)'), |
| InstantiateTestData(F5, [num_], 'void Function(num*)'), |
| InstantiateTestData(F6, [int_], 'void Function(int*)'), |
| InstantiateTestData(F7, [int_], 'void Function(int*,[int*])'), |
| InstantiateTestData(F8, [int_], 'int* Function(int*)'), |
| InstantiateTestData(F9, [int_, num_], 'void Function(int*,num*)'), |
| InstantiateTestData(F10, [int_, num_], 'void Function(int*,num*)'), |
| InstantiateTestData(F11, [C4], 'void Function(C4*)'), |
| InstantiateTestData(F12, [C4], 'void Function(C4*)'), |
| InstantiateTestData(F13, [C1], 'C1* Function(C1*,C1*)'), |
| InstantiateTestData(F14, [C2], 'C2* Function(C2*,C2*)'), |
| InstantiateTestData( |
| F15, [int_, num_], 'Map<C5.T*,int*>* Function(int*,num*)'), |
| InstantiateTestData( |
| F16, [num_, int_], 'Map<C5.T*,num*>* Function(num*,int*)'), |
| ]; |
| |
| for (var test in instantiateExpected) { |
| testInstantiate(test.type, test.instantiation, test.expected); |
| } |
| |
| List<SubstTestData> substExpected = [ |
| SubstTestData([num_], [C5_T], F15, |
| 'Map<num*,#A*>* Function<#A extends #B*,#B extends num*>(#A*,#B*)'), |
| SubstTestData([num_], [C5_T], F16, |
| 'Map<num*,#A*>* Function<#A extends num*,#B extends #A*>(#A*,#B*)'), |
| SubstTestData( |
| [num_], |
| [C5_T], |
| F17, |
| 'num* Function<#A extends List<#B*>*,' |
| '#B extends Map<num*,#A*>*>(#A*,#B*,Object*)'), |
| SubstTestData( |
| [num_], |
| [C5_T], |
| F18, |
| 'num* Function<#A extends num*>([' |
| '#A2* Function<#A2 extends #A*>(#A*,#A2*,num*)*,' |
| '#A3* Function<#A3 extends #A*>(#A*,#A3*,num*)*])'), |
| ]; |
| |
| for (var test in substExpected) { |
| testSubst(test.arguments, test.parameters, test.type, test.expected); |
| } |
| |
| Map<DartType, List<DartType>> expectedEquals = { |
| F1: [F2], |
| F2: [F1], |
| F9: [F10], |
| F10: [F9], |
| F11: [F12], |
| F12: [F11], |
| F13: [F14], |
| F14: [F13], |
| }; |
| |
| Map<DartType, List<DartType>> expectedSubtype = { |
| F7: [F5], |
| F8: [F5], |
| }; |
| |
| for (DartType f1 in all) { |
| for (DartType f2 in all) { |
| testRelations(f1, f2, |
| areEqual: identical(f1, f2) || |
| (expectedEquals[f1]?.contains(f2) ?? false), |
| isSubtype: expectedSubtype[f1]?.contains(f2) ?? false); |
| } |
| } |
| |
| var functionF1 = F1.withoutNullabilityAs<FunctionType>(); |
| var functionF2 = F2.withoutNullabilityAs<FunctionType>(); |
| testRelations( |
| functionF1.typeVariables.first, functionF1.typeVariables.first, |
| areEqual: true); |
| testRelations( |
| functionF1.typeVariables.first, functionF2.typeVariables.first); |
| |
| env.elementEnvironment.forEachConstructor(C3, |
| (ConstructorEntity constructor) { |
| Expect.equals( |
| 0, |
| constructor.parameterStructure.typeParameters, |
| "Type parameters found on constructor $constructor: " |
| "${constructor.parameterStructure}"); |
| List<TypeVariableType> functionTypeVariables = |
| env.elementEnvironment.getFunctionTypeVariables(constructor); |
| Expect.isTrue( |
| functionTypeVariables.isEmpty, |
| "Function type variables found on constructor $constructor: " |
| "${env.printTypes(functionTypeVariables)}"); |
| }); |
| }); |
| } |
