languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-14 09:58:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Don't use ElementsTypesMixin in resolution tests.

Browse source 
Change-Id: Ia4a8ebf9f31e22958ff63d7ce02f1ef76bb560aa
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/213320
Reviewed-by: Samuel Rawlins <srawlins@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
This commit is contained in:
Konstantin Shcheglov 2021-09-14 16:49:42 +00:00 committed by commit-bot@chromium.org
parent 9dd6854112
commit a4b3ae735a
7 changed files with 59 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
pkg/analyzer/test/src/dart/resolution/ast_rewrite_test.dart
View file

@ -463,7 +463,7 @@ void f() {
assertTypeNull(override);
assertTypeNull(override.extensionName);
assertElementTypeStrings(
assertElementTypes(
override.typeArgumentTypes,
expectedTypeArguments,
);

28
pkg/analyzer/test/src/dart/resolution/class_alias_test.dart
View file

@ -5,7 +5,6 @@
import 'package:analyzer/src/error/codes.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../../generated/elements_types_mixin.dart';
import 'context_collection_resolution.dart';
main() {
@ -15,8 +14,7 @@ main() {
}
@reflectiveTest
class ClassAliasDriverResolutionTest extends PubPackageResolutionTest
with ElementsTypesMixin {
class ClassAliasDriverResolutionTest extends PubPackageResolutionTest {
test_defaultConstructor() async {
await assertNoErrorsInCode(r'''
class A {}
@ -42,8 +40,8 @@ class X = A with B implements C;
assertTypeName(findNode.typeName('C;'), findElement.class_('C'), 'C');
assertType(x.supertype, 'A');
assertElementTypeStrings(x.mixins, ['B']);
assertElementTypeStrings(x.interfaces, ['C']);
assertElementTypes(x.mixins, ['B']);
assertElementTypes(x.interfaces, ['C']);
}
test_element_typeFunction_extends() async {
@ -61,16 +59,8 @@ class A {}
class B {}
class X = Object with A implements A, Function, B;
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
var x = findElement.class_('X');
assertElementTypes(
x.interfaces,
[
interfaceTypeNone(a),
interfaceTypeNone(b),
],
);
assertElementTypes(x.interfaces, ['A', 'B']);
}
test_element_typeFunction_with() async {
@ -79,16 +69,8 @@ class A {}
class B {}
class X = Object with A, Function, B;
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
var x = findElement.class_('X');
assertElementTypes(
x.mixins,
[
interfaceTypeNone(a),
interfaceTypeNone(b),
],
);
assertElementTypes(x.mixins, ['A', 'B']);
}
test_implicitConstructors_const() async {

64
pkg/analyzer/test/src/dart/resolution/class_test.dart
View file

@ -7,7 +7,6 @@ import 'package:analyzer/src/error/codes.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../../generated/elements_types_mixin.dart';
import 'context_collection_resolution.dart';
main() {
@ -17,8 +16,7 @@ main() {
}
@reflectiveTest
class ClassDriverResolutionTest extends PubPackageResolutionTest
with ElementsTypesMixin {
class ClassDriverResolutionTest extends PubPackageResolutionTest {
test_element_allSupertypes() async {
await assertNoErrorsInCode(r'''
class A {}
@ -34,37 +32,25 @@ class X4 extends A with B implements C {}
class X5 extends A with B, C implements D, E {}
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
var c = findElement.class_('C');
var d = findElement.class_('D');
var e = findElement.class_('E');
var typeA = interfaceTypeNone(a);
var typeB = interfaceTypeNone(b);
var typeC = interfaceTypeNone(c);
var typeD = interfaceTypeNone(d);
var typeE = interfaceTypeNone(e);
assertElementTypes(
findElement.class_('X1').allSupertypes,
[typeA, objectType],
['Object', 'A'],
);
assertElementTypes(
findElement.class_('X2').allSupertypes,
[objectType, typeB],
['Object', 'B'],
);
assertElementTypes(
findElement.class_('X3').allSupertypes,
[typeA, objectType, typeB],
['Object', 'A', 'B'],
);
assertElementTypes(
findElement.class_('X4').allSupertypes,
[typeA, typeB, objectType, typeC],
['Object', 'A', 'B', 'C'],
);
assertElementTypes(
findElement.class_('X5').allSupertypes,
[typeA, typeB, typeC, objectType, typeD, typeE],
['Object', 'A', 'B', 'C', 'D', 'E'],
);
}
@ -79,33 +65,17 @@ class X2 extends B<String, List<int>> {}
class X3 extends C<double> {}
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
var c = findElement.class_('C');
assertElementTypes(
findElement.class_('X1').allSupertypes,
[
interfaceTypeNone(a, typeArguments: [stringType]),
objectType
],
['Object', 'A<String>'],
);
assertElementTypes(
findElement.class_('X2').allSupertypes,
[
interfaceTypeNone(b, typeArguments: [
stringType,
interfaceTypeNone(listElement, typeArguments: [intType])
]),
objectType
],
['Object', 'B<String, List<int>>'],
);
assertElementTypes(
findElement.class_('X3').allSupertypes,
[
interfaceTypeNone(c, typeArguments: [doubleType]),
interfaceTypeNone(b, typeArguments: [intType, doubleType]),
objectType
],
['Object', 'B<int, double>', 'C<double>'],
);
}
@ -122,12 +92,9 @@ class X extends A {}
error(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, 48, 1),
]);
var a = findElement.class_('A');
var b = findElement.class_('B');
var c = findElement.class_('C');
assertElementTypes(
findElement.class_('X').allSupertypes,
[interfaceTypeNone(a), interfaceTypeNone(b), interfaceTypeNone(c)],
['A', 'B', 'C'],
);
}
@ -149,15 +116,10 @@ class C extends Object with A, Function, B {}
''', [
error(HintCode.DEPRECATED_MIXIN_FUNCTION, 53, 8),
]);
var a = findElement.class_('A');
var b = findElement.class_('B');
var c = findElement.class_('C');
assertElementTypes(
c.mixins,
[
interfaceTypeNone(a),
interfaceTypeNone(b),
],
findElement.class_('C').mixins,
['A', 'B'],
);
}

84
pkg/analyzer/test/src/dart/resolution/mixin_test.dart
View file

@ -2,13 +2,11 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/src/dart/error/syntactic_errors.dart';
import 'package:analyzer/src/error/codes.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../../generated/elements_types_mixin.dart';
import 'context_collection_resolution.dart';
main() {
@ -18,8 +16,7 @@ main() {
}
@reflectiveTest
class MixinDriverResolutionTest extends PubPackageResolutionTest
with ElementsTypesMixin {
class MixinDriverResolutionTest extends PubPackageResolutionTest {
test_accessor_getter() async {
await assertNoErrorsInCode(r'''
mixin M {
@ -94,7 +91,7 @@ class A extends Object with M {} // A
var mElement = findElement.mixin('M');
var aElement = findElement.class_('A');
assertElementTypes(aElement.mixins, [interfaceTypeNone(mElement)]);
assertElementTypes(aElement.mixins, ['M']);
var mRef = findNode.typeName('M {} // A');
assertTypeName(mRef, mElement, 'M');
@ -109,7 +106,7 @@ class A = Object with M;
var mElement = findElement.mixin('M');
var aElement = findElement.class_('A');
assertElementTypes(aElement.mixins, [interfaceTypeNone(mElement)]);
assertElementTypes(aElement.mixins, ['M']);
var mRef = findNode.typeName('M;');
assertTypeName(mRef, mElement, 'M');
@ -144,10 +141,13 @@ mixin M {}
expect(element.isEnum, isFalse);
expect(element.isMixin, isTrue);
expect(element.isMixinApplication, isFalse);
expect(interfaceTypeStar(element).isDartCoreObject, isFalse);
expect(element.thisType.isDartCoreObject, isFalse);
expect(element.isDartCoreObject, isFalse);
assertElementTypes(element.superclassConstraints, [objectType]);
assertElementTypes(
element.superclassConstraints,
['Object'],
);
assertElementTypes(element.interfaces, []);
}
@ -161,21 +161,13 @@ mixin M1 on A, B {}
mixin M2 on A implements B, C {}
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
var c = findElement.class_('C');
assertElementTypes(
findElement.mixin('M1').allSupertypes,
[interfaceTypeNone(a), interfaceTypeNone(b), objectType],
['Object', 'A', 'B'],
);
assertElementTypes(
findElement.mixin('M2').allSupertypes,
[
interfaceTypeNone(a),
objectType,
interfaceTypeNone(b),
interfaceTypeNone(c)
],
['Object', 'A', 'B', 'C'],
);
}
@ -188,22 +180,13 @@ mixin M1 on A<int, double> {}
mixin M2 on B<String> {}
''');
var a = findElement.class_('A');
var b = findElement.class_('B');
assertElementTypes(
findElement.mixin('M1').allSupertypes,
[
interfaceTypeNone(a, typeArguments: [intType, doubleType]),
objectType
],
['Object', 'A<int, double>'],
);
assertElementTypes(
findElement.mixin('M2').allSupertypes,
[
interfaceTypeNone(b, typeArguments: [stringType]),
interfaceTypeNone(a, typeArguments: [intType, stringType]),
objectType
],
['Object', 'A<int, String>', 'B<String>'],
);
}
@ -323,7 +306,7 @@ mixin M implements math.Random {}
var randomElement = mathImport.importedLibrary!.getType('Random')!;
var element = findElement.mixin('M');
assertElementTypes(element.interfaces, [interfaceTypeNone(randomElement)]);
assertElementTypes(element.interfaces, ['Random']);
var typeRef = findNode.typeName('Random {}');
assertTypeName(typeRef, randomElement, 'Random',
@ -338,7 +321,7 @@ mixin M implements int {}
]);
var element = findElement.mixin('M');
assertElementTypes(element.interfaces, [intType]);
assertElementTypes(element.interfaces, ['int']);
var typeRef = findNode.typeName('int {}');
assertTypeName(typeRef, intElement, 'int');
@ -846,9 +829,7 @@ mixin M on math.Random {}
var randomElement = mathImport.importedLibrary!.getType('Random')!;
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [
interfaceTypeNone(randomElement),
]);
assertElementTypes(element.superclassConstraints, ['Random']);
var typeRef = findNode.typeName('Random {}');
assertTypeName(typeRef, randomElement, 'Random',
@ -864,7 +845,7 @@ mixin M on int {}
]);
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [intType]);
assertElementTypes(element.superclassConstraints, ['int']);
var typeRef = findNode.typeName('int {}');
assertTypeName(typeRef, intElement, 'int');
@ -879,7 +860,7 @@ mixin M on dynamic {}
]);
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [objectType]);
assertElementTypes(element.superclassConstraints, ['Object']);
var typeRef = findNode.typeName('dynamic {}');
assertTypeName(typeRef, dynamicElement, 'dynamic');
@ -895,7 +876,7 @@ mixin M on E {}
]);
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [objectType]);
assertElementTypes(element.superclassConstraints, ['Object']);
var typeRef = findNode.typeName('E {}');
assertTypeName(typeRef, findElement.enum_('E'), 'E');
@ -911,7 +892,7 @@ mixin M on void {}
]);
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [objectType]);
assertElementTypes(element.superclassConstraints, ['Object']);
var typeRef = findNode.typeName('void {}');
assertTypeName(typeRef, null, 'void');
@ -923,11 +904,8 @@ mixin A {}
mixin B on A {} // ref
''');
var a = findElement.mixin('A');
var b = findElement.mixin('B');
assertElementTypes(b.superclassConstraints, [
interfaceTypeNone(a),
]);
assertElementTypes(b.superclassConstraints, ['A']);
}
test_error_undefinedSuperMethod() async {
@ -995,16 +973,7 @@ mixin M implements A, B {} // M
''');
var element = findElement.mixin('M');
assertElementTypes(element.interfaces, [
findElement.class_('A').instantiate(
typeArguments: const [],
nullabilitySuffix: NullabilitySuffix.none,
),
findElement.class_('B').instantiate(
typeArguments: const [],
nullabilitySuffix: NullabilitySuffix.none,
),
]);
assertElementTypes(element.interfaces, ['A', 'B']);
var aRef = findNode.typeName('A, ');
assertTypeName(aRef, findElement.class_('A'), 'A');
@ -1092,16 +1061,7 @@ mixin M on A, B {} // M
''');
var element = findElement.mixin('M');
assertElementTypes(element.superclassConstraints, [
findElement.class_('A').instantiate(
typeArguments: const [],
nullabilitySuffix: NullabilitySuffix.none,
),
findElement.class_('B').instantiate(
typeArguments: const [],
nullabilitySuffix: NullabilitySuffix.none,
),
]);
assertElementTypes(element.superclassConstraints, ['A', 'B']);
var aRef = findNode.typeName('A, ');
assertTypeName(aRef, findElement.class_('A'), 'A');

21
pkg/analyzer/test/src/dart/resolution/resolution.dart
View file

@ -265,21 +265,18 @@ mixin ResolutionTest implements ResourceProviderMixin {
expect(str, expected);
}
void assertElementTypes(List<DartType> types, List<DartType> expected,
void assertElementTypes(List<DartType>? types, List<String> expected,
{bool ordered = false}) {
if (ordered) {
expect(types, expected);
} else {
expect(types, unorderedEquals(expected));
}
}
void assertElementTypeStrings(List<DartType>? types, List<String> expected) {
if (types == null) {
fail('Expected types, actually null.');
}
expect(types.map(typeString).toList(), expected);
var typeStrList = types.map(typeString).toList();
if (ordered) {
expect(typeStrList, expected);
} else {
expect(typeStrList, unorderedEquals(expected));
}
}
void assertEnclosingElement(Element element, Element expectedEnclosing) {
@ -346,7 +343,7 @@ mixin ResolutionTest implements ResourceProviderMixin {
}) {
assertElement(node, element);
assertType(node.extendedType, extendedType);
assertElementTypeStrings(node.typeArgumentTypes, typeArgumentTypes);
assertElementTypes(node.typeArgumentTypes, typeArgumentTypes);
}
void assertFunctionExpressionInvocation(
@ -766,7 +763,7 @@ mixin ResolutionTest implements ResourceProviderMixin {
required List<String> typeArguments,
}) {
assertElement2(type.alias?.element, declaration: element);
assertElementTypeStrings(type.alias?.typeArguments, typeArguments);
assertElementTypes(type.alias?.typeArguments, typeArguments);
}
/// Assert that the given [identifier] is a reference to a type alias, in the

16
pkg/analyzer/test/src/dart/resolution/type_inference/extension_methods_test.dart
View file

@ -371,7 +371,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E<num>(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['num']);
assertElementTypes(override.typeArgumentTypes, ['num']);
assertType(override.extendedType, 'A<num>');
var propertyAccess = findNode.propertyAccess('.foo');
@ -397,7 +397,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E<num>(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['num']);
assertElementTypes(override.typeArgumentTypes, ['num']);
assertType(override.extendedType, 'A<num>');
// TODO(scheglov) We need to instantiate "foo" fully.
@ -450,7 +450,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E<num>(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['num']);
assertElementTypes(override.typeArgumentTypes, ['num']);
assertType(override.extendedType, 'A<num>');
assertAssignment(
@ -489,7 +489,7 @@ f(String s) {
error(CompileTimeErrorCode.COULD_NOT_INFER, 69, 1),
]);
var override = findNode.extensionOverride('E(s)');
assertElementTypeStrings(override.typeArgumentTypes, ['String']);
assertElementTypes(override.typeArgumentTypes, ['String']);
assertType(override.extendedType, 'String');
}
@ -507,7 +507,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['int']);
assertElementTypes(override.typeArgumentTypes, ['int']);
assertType(override.extendedType, 'A<int>');
var propertyAccess = findNode.propertyAccess('.foo');
@ -533,7 +533,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['int']);
assertElementTypes(override.typeArgumentTypes, ['int']);
assertType(override.extendedType, 'A<int>');
// TODO(scheglov) We need to instantiate "foo" fully.
@ -565,7 +565,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['int']);
assertElementTypes(override.typeArgumentTypes, ['int']);
assertType(override.extendedType, 'A<int>');
var propertyAccess = findNode.propertyAccess('foo;');
@ -591,7 +591,7 @@ void f(A<int> a) {
''');
var override = findNode.extensionOverride('E(a)');
assertElement(override, findElement.extension_('E'));
assertElementTypeStrings(override.typeArgumentTypes, ['int']);
assertElementTypes(override.typeArgumentTypes, ['int']);
assertType(override.extendedType, 'A<int>');
assertAssignment(

2
pkg/analyzer/test/src/dart/resolution/type_inference/tear_off_test.dart
View file

@ -145,7 +145,7 @@ void test() {
assertElement(id, element);
assertType(id, type);
if (typeArguments != null) {
assertElementTypeStrings(id.tearOffTypeArgumentTypes, typeArguments);
assertElementTypes(id.tearOffTypeArgumentTypes, typeArguments);
} else {
expect(id.tearOffTypeArgumentTypes, isNull);
}