| // Copyright (c) 2020, 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:front_end/src/fasta/type_inference/type_constraint_gatherer.dart'; |
| import 'package:front_end/src/fasta/type_inference/type_schema.dart'; |
| import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart'; |
| import 'package:kernel/ast.dart'; |
| import 'package:kernel/core_types.dart'; |
| import 'package:kernel/class_hierarchy.dart'; |
| import 'package:kernel/testing/mock_sdk_component.dart'; |
| import 'package:test/test.dart'; |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| |
| main() { |
| defineReflectiveSuite(() { |
| defineReflectiveTests(TypeConstraintGathererTest); |
| }); |
| } |
| |
| @reflectiveTest |
| class TypeConstraintGathererTest { |
| static const UnknownType unknownType = const UnknownType(); |
| |
| static const DynamicType dynamicType = const DynamicType(); |
| |
| static const VoidType voidType = const VoidType(); |
| |
| final testLib = |
| new Library(Uri.parse('org-dartlang:///test.dart'), name: 'lib') |
| ..isNonNullableByDefault = true; |
| |
| Component component; |
| |
| CoreTypes coreTypes; |
| |
| TypeParameterType T1; |
| TypeParameterType T2; |
| TypeParameterType S1; |
| TypeParameterType S2; |
| TypeParameterType R1; |
| TypeParameterType R2; |
| |
| Class classP; |
| |
| Class classQ; |
| |
| TypeConstraintGathererTest() { |
| component = createMockSdkComponent(); |
| component.libraries.add(testLib..parent = component); |
| coreTypes = new CoreTypes(component); |
| T1 = new TypeParameterType( |
| new TypeParameter('T1', coreTypes.objectLegacyRawType), |
| Nullability.legacy); |
| T2 = new TypeParameterType( |
| new TypeParameter('T2', coreTypes.objectLegacyRawType), |
| Nullability.legacy); |
| S1 = new TypeParameterType( |
| new TypeParameter('S1', coreTypes.objectNullableRawType), |
| Nullability.undetermined); |
| S2 = new TypeParameterType( |
| new TypeParameter('S2', coreTypes.objectNullableRawType), |
| Nullability.undetermined); |
| R1 = new TypeParameterType( |
| new TypeParameter('R1', coreTypes.objectNonNullableRawType), |
| Nullability.nonNullable); |
| R2 = new TypeParameterType( |
| new TypeParameter('R2', coreTypes.objectNonNullableRawType), |
| Nullability.nonNullable); |
| classP = _addClass(_class('P')); |
| classQ = _addClass(_class('Q')); |
| } |
| |
| Class get functionClass => coreTypes.functionClass; |
| |
| InterfaceType get functionType => coreTypes.functionLegacyRawType; |
| |
| Class get iterableClass => coreTypes.iterableClass; |
| |
| Class get listClass => coreTypes.listClass; |
| |
| Class get mapClass => coreTypes.mapClass; |
| |
| Class get objectClass => coreTypes.objectClass; |
| |
| InterfaceType get P => coreTypes.legacyRawType(classP); |
| |
| InterfaceType get Q => coreTypes.legacyRawType(classQ); |
| |
| void test_any_subtype_parameter() { |
| DartType nullableQ = Q.withDeclaredNullability(Nullability.nullable); |
| DartType nonNullableQ = Q.withDeclaredNullability(Nullability.nonNullable); |
| |
| _checkConstraintsLower(T1, nullableQ, testLib, ['lib::Q? <: T1']); |
| _checkConstraintsLower(T1, nonNullableQ, testLib, ['lib::Q <: T1']); |
| _checkConstraintsUpper(T1, nullableQ, testLib, ['T1 <: lib::Q?']); |
| _checkConstraintsUpper(T1, nonNullableQ, testLib, ['T1 <: lib::Q']); |
| |
| DartType nullableS1 = S1.withDeclaredNullability(Nullability.nullable); |
| _checkConstraintsLower(S1, nonNullableQ, testLib, ['lib::Q <: S1']); |
| _checkConstraintsLower(S1, nullableQ, testLib, ['lib::Q? <: S1']); |
| _checkConstraintsLower(nullableS1, nonNullableQ, testLib, ['lib::Q <: S1']); |
| _checkConstraintsLower(nullableS1, nullableQ, testLib, ['lib::Q <: S1']); |
| _checkConstraintsUpper(S1, nonNullableQ, testLib, ['S1 <: lib::Q']); |
| _checkConstraintsUpper(S1, nullableQ, testLib, ['S1 <: lib::Q?']); |
| _checkConstraintsUpper(nullableS1, nonNullableQ, testLib, null); |
| _checkConstraintsUpper(nullableS1, nullableQ, testLib, ['S1 <: lib::Q']); |
| } |
| |
| void test_any_subtype_top() { |
| _checkConstraintsUpper(P, dynamicType, testLib, []); |
| _checkConstraintsUpper(P, coreTypes.objectLegacyRawType, testLib, []); |
| _checkConstraintsUpper(P, voidType, testLib, []); |
| } |
| |
| void test_any_subtype_unknown() { |
| _checkConstraintsUpper(P, unknownType, testLib, []); |
| _checkConstraintsUpper(T1, unknownType, testLib, []); |
| _checkConstraintsUpper(S1, unknownType, testLib, []); |
| _checkConstraintsUpper(R1, unknownType, testLib, []); |
| } |
| |
| void test_different_classes() { |
| _checkConstraintsUpper(_list(T1), _iterable(Q), testLib, ['T1 <: lib::Q*']); |
| _checkConstraintsUpper(_iterable(T1), _list(Q), testLib, null); |
| _checkConstraintsUpper(_list(S1), _iterable(Q), testLib, ['S1 <: lib::Q*']); |
| _checkConstraintsUpper(_iterable(S1), _list(Q), testLib, null); |
| _checkConstraintsUpper(_list(R1), _iterable(Q), testLib, ['R1 <: lib::Q*']); |
| _checkConstraintsUpper(_iterable(R1), _list(Q), testLib, null); |
| } |
| |
| void test_equal_types() { |
| _checkConstraintsUpper(P, P, testLib, []); |
| } |
| |
| void test_function_generic() { |
| var T = new TypeParameterType( |
| new TypeParameter('T', coreTypes.objectLegacyRawType), |
| Nullability.legacy); |
| var U = new TypeParameterType( |
| new TypeParameter('U', coreTypes.objectLegacyRawType), |
| Nullability.legacy); |
| // <T>() -> dynamic <: () -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy, |
| typeParameters: [T.parameter]), |
| new FunctionType([], dynamicType, Nullability.legacy), |
| testLib, |
| null); |
| // () -> dynamic <: <T>() -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy), |
| new FunctionType([], dynamicType, Nullability.legacy, |
| typeParameters: [T.parameter]), |
| testLib, |
| null); |
| // <T>(T) -> T <: <U>(U) -> U, always |
| _checkConstraintsUpper( |
| new FunctionType([T], T, Nullability.legacy, |
| typeParameters: [T.parameter]), |
| new FunctionType([U], U, Nullability.legacy, |
| typeParameters: [U.parameter]), |
| testLib, |
| []); |
| } |
| |
| void test_function_parameter_mismatch() { |
| // (P) -> dynamic <: () -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([P], dynamicType, Nullability.legacy), |
| new FunctionType([], dynamicType, Nullability.legacy), |
| testLib, |
| null); |
| // () -> dynamic <: (P) -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy), |
| new FunctionType([P], dynamicType, Nullability.legacy), |
| testLib, |
| null); |
| // ([P]) -> dynamic <: () -> dynamic, always |
| _checkConstraintsUpper( |
| new FunctionType([P], dynamicType, Nullability.legacy, |
| requiredParameterCount: 0), |
| new FunctionType([], dynamicType, Nullability.legacy), |
| testLib, |
| []); |
| // () -> dynamic <: ([P]) -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy), |
| new FunctionType([P], dynamicType, Nullability.legacy, |
| requiredParameterCount: 0), |
| testLib, |
| null); |
| // ({x: P}) -> dynamic <: () -> dynamic, always |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy, |
| namedParameters: [new NamedType('x', P)]), |
| new FunctionType([], dynamicType, Nullability.legacy), |
| testLib, |
| []); |
| // () -> dynamic !<: ({x: P}) -> dynamic, never |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy), |
| new FunctionType([], dynamicType, Nullability.legacy, |
| namedParameters: [new NamedType('x', P)]), |
| testLib, |
| null); |
| } |
| |
| void test_function_parameter_types() { |
| // (T1) -> dynamic <: (Q) -> dynamic, under constraint Q <: T1 |
| _checkConstraintsUpper( |
| new FunctionType([T1], dynamicType, Nullability.legacy), |
| new FunctionType([Q], dynamicType, Nullability.legacy), |
| testLib, |
| ['lib::Q* <: T1']); |
| // ({x: T1}) -> dynamic <: ({x: Q}) -> dynamic, under constraint Q <: T1 |
| _checkConstraintsUpper( |
| new FunctionType([], dynamicType, Nullability.legacy, |
| namedParameters: [new NamedType('x', T1)]), |
| new FunctionType([], dynamicType, Nullability.legacy, |
| namedParameters: [new NamedType('x', Q)]), |
| testLib, |
| ['lib::Q* <: T1']); |
| // (S1) -> S1? <: (P) -> P? |
| _checkConstraintsUpper( |
| new FunctionType([S1], S1.withDeclaredNullability(Nullability.nullable), |
| Nullability.nonNullable), |
| new FunctionType( |
| [P.withDeclaredNullability(Nullability.nonNullable)], |
| P.withDeclaredNullability(Nullability.nullable), |
| Nullability.nonNullable), |
| testLib, |
| ['lib::P <: S1 <: lib::P']); |
| // (S1, List<S1?>) -> void <: (P, List<P?>) -> void |
| _checkConstraintsUpper( |
| new FunctionType( |
| [S1, _list(S1.withDeclaredNullability(Nullability.nullable))], |
| voidType, |
| Nullability.nonNullable), |
| new FunctionType([ |
| P.withDeclaredNullability(Nullability.nonNullable), |
| _list(P.withDeclaredNullability(Nullability.nullable)) |
| ], voidType, Nullability.nonNullable), |
| testLib, |
| ['lib::P <: S1']); |
| } |
| |
| void test_function_return_type() { |
| // () -> T1 <: () -> Q, under constraint T1 <: Q |
| _checkConstraintsUpper( |
| new FunctionType([], T1, Nullability.legacy), |
| new FunctionType([], Q, Nullability.legacy), |
| testLib, |
| ['T1 <: lib::Q*']); |
| // () -> P <: () -> void, always |
| _checkConstraintsUpper(new FunctionType([], P, Nullability.legacy), |
| new FunctionType([], voidType, Nullability.legacy), testLib, []); |
| // () -> void <: () -> P, never |
| _checkConstraintsUpper(new FunctionType([], voidType, Nullability.legacy), |
| new FunctionType([], P, Nullability.legacy), testLib, null); |
| } |
| |
| void test_function_trivial_cases() { |
| var F = new FunctionType([], dynamicType, Nullability.legacy); |
| // () -> dynamic <: dynamic, always |
| _checkConstraintsUpper(F, dynamicType, testLib, []); |
| // () -> dynamic <: Function, always |
| _checkConstraintsUpper(F, functionType, testLib, []); |
| // () -> dynamic <: Object, always |
| _checkConstraintsUpper(F, coreTypes.objectLegacyRawType, testLib, []); |
| } |
| |
| void test_nonInferredParameter_subtype_any() { |
| var U = new TypeParameterType( |
| new TypeParameter('U', _list(P)), Nullability.legacy); |
| _checkConstraintsLower(_list(T1), U, testLib, ['lib::P* <: T1']); |
| } |
| |
| void test_null_subtype_any() { |
| _checkConstraintsLower(T1, new NullType(), testLib, ['Null <: T1']); |
| _checkConstraintsUpper(new NullType(), Q, testLib, []); |
| } |
| |
| void test_parameter_subtype_any() { |
| _checkConstraintsUpper(T1, Q, testLib, ['T1 <: lib::Q*']); |
| _checkConstraintsLower(T1, Q, testLib, ['lib::Q* <: T1']); |
| |
| _checkConstraintsUpper(S1, Q, testLib, ['S1 <: lib::Q*']); |
| _checkConstraintsLower(S1, Q, testLib, ['lib::Q* <: S1']); |
| _checkConstraintsUpper(S1.withDeclaredNullability(Nullability.legacy), Q, |
| testLib, ['S1 <: lib::Q*']); |
| _checkConstraintsLower(S1.withDeclaredNullability(Nullability.legacy), Q, |
| testLib, ['lib::Q <: S1']); |
| |
| _checkConstraintsUpper(R1, Q, testLib, ['R1 <: lib::Q*']); |
| _checkConstraintsLower(R1, Q, testLib, ['lib::Q* <: R1']); |
| _checkConstraintsUpper(R1.withDeclaredNullability(Nullability.legacy), Q, |
| testLib, ['R1 <: lib::Q*']); |
| _checkConstraintsLower(R1.withDeclaredNullability(Nullability.legacy), Q, |
| testLib, ['lib::Q <: R1']); |
| } |
| |
| void test_same_classes() { |
| _checkConstraintsUpper(_list(T1), _list(Q), testLib, ['T1 <: lib::Q*']); |
| } |
| |
| void test_typeParameters() { |
| _checkConstraintsUpper( |
| _map(T1, T2), _map(P, Q), testLib, ['T1 <: lib::P*', 'T2 <: lib::Q*']); |
| _checkConstraintsLower( |
| _map(T1, T2), _map(P, Q), testLib, ['lib::P* <: T1', 'lib::Q* <: T2']); |
| |
| _checkConstraintsUpper( |
| _map(S1, S2), _map(P, Q), testLib, ['S1 <: lib::P*', 'S2 <: lib::Q*']); |
| _checkConstraintsLower( |
| _map(S1, S2), _map(P, Q), testLib, ['lib::P* <: S1', 'lib::Q* <: S2']); |
| _checkConstraintsUpper( |
| _map(S1.withDeclaredNullability(Nullability.legacy), |
| S2.withDeclaredNullability(Nullability.legacy)), |
| _map(P, Q), |
| testLib, |
| ['S1 <: lib::P*', 'S2 <: lib::Q*']); |
| _checkConstraintsLower( |
| _map(S1.withDeclaredNullability(Nullability.legacy), |
| S2.withDeclaredNullability(Nullability.legacy)), |
| _map(P, Q), |
| testLib, |
| ['lib::P <: S1', 'lib::Q <: S2']); |
| |
| _checkConstraintsUpper( |
| _map(R1, R2), _map(P, Q), testLib, ['R1 <: lib::P*', 'R2 <: lib::Q*']); |
| _checkConstraintsLower( |
| _map(R1, R2), _map(P, Q), testLib, ['lib::P* <: R1', 'lib::Q* <: R2']); |
| _checkConstraintsUpper( |
| _map(R1.withDeclaredNullability(Nullability.legacy), |
| R2.withDeclaredNullability(Nullability.legacy)), |
| _map(P, Q), |
| testLib, |
| ['R1 <: lib::P*', 'R2 <: lib::Q*']); |
| _checkConstraintsLower( |
| _map(R1.withDeclaredNullability(Nullability.legacy), |
| R2.withDeclaredNullability(Nullability.legacy)), |
| _map(P, Q), |
| testLib, |
| ['lib::P <: R1', 'lib::Q <: R2']); |
| } |
| |
| void test_unknown_subtype_any() { |
| _checkConstraintsLower(Q, unknownType, testLib, []); |
| _checkConstraintsLower(T1, unknownType, testLib, []); |
| } |
| |
| Class _addClass(Class c) { |
| testLib.addClass(c); |
| return c; |
| } |
| |
| void _checkConstraintsLower(DartType type, DartType bound, |
| Library clientLibrary, List<String> expectedConstraints) { |
| _checkConstraintsHelper(type, bound, clientLibrary, expectedConstraints, |
| (gatherer, type, bound) => gatherer.tryConstrainLower(type, bound)); |
| } |
| |
| void _checkConstraintsUpper(DartType type, DartType bound, |
| Library clientLibrary, List<String> expectedConstraints) { |
| _checkConstraintsHelper(type, bound, clientLibrary, expectedConstraints, |
| (gatherer, type, bound) => gatherer.tryConstrainUpper(type, bound)); |
| } |
| |
| void _checkConstraintsHelper( |
| DartType a, |
| DartType b, |
| Library clientLibrary, |
| List<String> expectedConstraints, |
| bool Function(TypeConstraintGatherer, DartType, DartType) tryConstrain) { |
| var typeSchemaEnvironment = new TypeSchemaEnvironment( |
| coreTypes, new ClassHierarchy(component, coreTypes)); |
| var typeConstraintGatherer = new TypeConstraintGatherer( |
| typeSchemaEnvironment, |
| [ |
| T1.parameter, |
| T2.parameter, |
| S1.parameter, |
| S2.parameter, |
| R1.parameter, |
| R2.parameter |
| ], |
| testLib); |
| var constraints = tryConstrain(typeConstraintGatherer, a, b) |
| ? typeConstraintGatherer.computeConstraints(clientLibrary) |
| : null; |
| if (expectedConstraints == null) { |
| expect(constraints, isNull); |
| return; |
| } |
| expect(constraints, isNotNull); |
| var constraintStrings = <String>[]; |
| constraints.forEach((t, constraint) { |
| if (constraint.lower is! UnknownType || |
| constraint.upper is! UnknownType) { |
| var s = t.name; |
| if (constraint.lower is! UnknownType) { |
| s = '${typeSchemaToString(constraint.lower)} <: $s'; |
| } |
| if (constraint.upper is! UnknownType) { |
| s = '$s <: ${typeSchemaToString(constraint.upper)}'; |
| } |
| constraintStrings.add(s); |
| } |
| }); |
| expect(constraintStrings, unorderedEquals(expectedConstraints)); |
| } |
| |
| Class _class(String name, |
| {Supertype supertype, |
| List<TypeParameter> typeParameters, |
| List<Supertype> implementedTypes}) { |
| return new Class( |
| name: name, |
| supertype: supertype ?? objectClass.asThisSupertype, |
| typeParameters: typeParameters, |
| implementedTypes: implementedTypes); |
| } |
| |
| DartType _iterable(DartType element) => |
| new InterfaceType(iterableClass, Nullability.legacy, [element]); |
| |
| DartType _list(DartType element) => |
| new InterfaceType(listClass, Nullability.legacy, [element]); |
| |
| DartType _map(DartType key, DartType value) => |
| new InterfaceType(mapClass, Nullability.legacy, [key, value]); |
| } |
