Perform instance member inference for mixins.
The set of sets is not comprehensive, no tests for fields and accessors.
R=brianwilkerson@google.com
Change-Id: I105ed6b1d4b5836f61af9f8abe7fed7e7a6b8c59
Reviewed-on: https://dart-review.googlesource.com/74941
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
diff --git a/pkg/analyzer/lib/src/summary/link.dart b/pkg/analyzer/lib/src/summary/link.dart
index 4fdd614..59f4e77 100644
--- a/pkg/analyzer/lib/src/summary/link.dart
+++ b/pkg/analyzer/lib/src/summary/link.dart
@@ -1555,6 +1555,9 @@
for (ClassElementForLink classElement in types) {
classElement.link(this);
}
+ for (ClassElementForLink classElement in mixins) {
+ classElement.link(this);
+ }
}
/// Throw away any information stored in the summary by a previous call to
diff --git a/pkg/analyzer/lib/src/task/strong_mode.dart b/pkg/analyzer/lib/src/task/strong_mode.dart
index f3fffb3..a0b6100 100644
--- a/pkg/analyzer/lib/src/task/strong_mode.dart
+++ b/pkg/analyzer/lib/src/task/strong_mode.dart
@@ -78,14 +78,8 @@
* compilation [unit].
*/
void inferCompilationUnit(CompilationUnitElement unit) {
- for (ClassElement classElement in unit.types) {
- try {
- _inferClass(classElement);
- } on _CycleException {
- // This is a short circuit return to prevent types that inherit from
- // types containing a circular reference from being inferred.
- }
- }
+ _inferClasses(unit.mixins);
+ _inferClasses(unit.types);
}
/**
@@ -306,6 +300,7 @@
_inferType(classElement.supertype);
classElement.mixins.forEach(_inferType);
classElement.interfaces.forEach(_inferType);
+ classElement.superclassConstraints.forEach(_inferType);
//
// Then infer the types for the members.
//
@@ -330,6 +325,17 @@
}
}
+ void _inferClasses(List<ClassElement> elements) {
+ for (ClassElement element in elements) {
+ try {
+ _inferClass(element);
+ } on _CycleException {
+ // This is a short circuit return to prevent types that inherit from
+ // types containing a circular reference from being inferred.
+ }
+ }
+ }
+
void _inferConstructorFieldFormals(ConstructorElement constructor) {
for (ParameterElement parameter in constructor.parameters) {
if (parameter.hasImplicitType &&
diff --git a/pkg/analyzer/test/src/dart/resolution/class_test.dart b/pkg/analyzer/test/src/dart/resolution/class_test.dart
index 8384f10..7edebf0 100644
--- a/pkg/analyzer/test/src/dart/resolution/class_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/class_test.dart
@@ -70,7 +70,10 @@
''');
await resolveTestFile();
assertTestErrors([CompileTimeErrorCode.ABSTRACT_SUPER_MEMBER_REFERENCE]);
- assertElement(findNode.simple('foo(); // ref'), findElement.method('foo'));
+ assertElement(
+ findNode.simple('foo(); // ref'),
+ findElement.method('foo', of: 'A'),
+ );
}
test_abstractSuperMemberReference_method_reference() async {
@@ -110,7 +113,7 @@
assertNoTestErrors();
assertElement(
findNode.simple('foo(); // ref'),
- findElement.method('foo', className: 'M'),
+ findElement.method('foo', of: 'M'),
);
}
@@ -137,7 +140,7 @@
assertNoTestErrors();
assertElement(
findNode.simple('foo(); // ref'),
- findElement.method('foo', className: 'B'),
+ findElement.method('foo', of: 'B'),
);
}
@@ -161,7 +164,7 @@
assertNoTestErrors();
assertElement(
findNode.simple('foo(); // ref'),
- findElement.method('foo', className: 'A'),
+ findElement.method('foo', of: 'A'),
);
}
@@ -207,7 +210,7 @@
assertNoTestErrors();
assertElement(
findNode.simple('foo(); // ref'),
- findElement.method('foo', className: 'A'),
+ findElement.method('foo', of: 'A'),
);
}
diff --git a/pkg/analyzer/test/src/dart/resolution/find_element.dart b/pkg/analyzer/test/src/dart/resolution/find_element.dart
index 105b4a4..fe7cb76 100644
--- a/pkg/analyzer/test/src/dart/resolution/find_element.dart
+++ b/pkg/analyzer/test/src/dart/resolution/find_element.dart
@@ -149,17 +149,37 @@
return result;
}
- MethodElement method(String name, {String className}) {
- for (var class_ in unitElement.types) {
- if (className != null && class_.name != className) {
- continue;
- }
- for (var method in class_.methods) {
+ MethodElement method(String name, {String of}) {
+ MethodElement result;
+
+ void findIn(List<MethodElement> methods) {
+ for (var method in methods) {
if (method.name == name) {
- return method;
+ if (result != null) {
+ throw new StateError('Method name $name is not unique.');
+ }
+ result = method;
}
}
}
+
+ for (var class_ in unitElement.types) {
+ if (of != null && class_.name != of) {
+ continue;
+ }
+ findIn(class_.methods);
+ }
+
+ for (var mixin in unitElement.mixins) {
+ if (of != null && mixin.name != of) {
+ continue;
+ }
+ findIn(mixin.methods);
+ }
+
+ if (result != null) {
+ return result;
+ }
fail('Not found class method: $name');
}
diff --git a/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart
new file mode 100644
index 0000000..1218643
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart
@@ -0,0 +1,296 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+import 'resolution.dart';
+import 'task_resolution.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(InstanceMemberInferenceClassDriverResolutionTest);
+ defineReflectiveTests(InstanceMemberInferenceClassTaskResolutionTest);
+ });
+}
+
+@reflectiveTest
+class InstanceMemberInferenceClassDriverResolutionTest
+ extends DriverResolutionTest with InstanceMemberInferenceClassMixin {}
+
+abstract class InstanceMemberInferenceClassMixin implements ResolutionTest {
+ test_invalid_inheritanceCycle() async {
+ addTestFile('''
+class A extends C {}
+class B extends A {}
+class C extends B {}
+''');
+ await resolveTestFile();
+ }
+
+ test_method_parameter_multiple_different() async {
+ addTestFile('''
+class A {
+ foo(int p) => 0;
+}
+class B {
+ foo(double p) => 0;
+}
+class C implements A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_named_different() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo({int q}) => 0;
+}
+class C implements A, B {
+ foo({p}) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_named_same() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo({int p}) => 0;
+}
+class C implements A, B {
+ foo({p}) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeString(p.type, 'int');
+ }
+
+ test_method_parameter_multiple_namedAndRequired() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo(int p) => 0;
+}
+class C implements A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_optionalAndRequired() async {
+ addTestFile('''
+class A {
+ foo(int p) => 0;
+}
+class B {
+ foo([int p]) => 0;
+}
+class C implements A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeString(p.type, 'int');
+ }
+
+ test_method_parameter_single_generic() async {
+ addTestFile('''
+class A<E> {
+ foo(E p) => 0;
+}
+class C<T> implements A<T> {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'C').parameters[0];
+ assertElementTypeString(p.type, 'T');
+ }
+
+ test_method_return_multiple_different() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ double foo() => 0.0;
+}
+class C implements A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_different_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => null;
+}
+class B<E> {
+ E foo() => null;
+}
+class C implements A<int>, B<double> {
+ foo() => null;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_different_void() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ void foo() => 0;
+}
+class C implements A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_dynamic() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ foo() => 0;
+}
+class C implements A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_same_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => 0;
+}
+class B<E> {
+ E foo() => 0;
+}
+class C<T> implements A<T>, B<T> {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeString(foo.returnType, 'T');
+ }
+
+ test_method_return_multiple_same_nonVoid() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ int foo() => 0;
+}
+class C implements A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeString(foo.returnType, 'int');
+ }
+
+ test_method_return_multiple_same_void() async {
+ addTestFile('''
+class A {
+ void foo() {};
+}
+class B {
+ void foo() {};
+}
+class C implements A, B {
+ foo() {};
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'C');
+ assertElementTypeString(foo.returnType, 'void');
+ }
+
+ test_method_return_single() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B extends A {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'B');
+ assertElementTypeString(foo.returnType, 'int');
+ }
+
+ test_method_return_single_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => 0;
+}
+class B<T> extends A<T> {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'B');
+ assertElementTypeString(foo.returnType, 'T');
+ }
+}
+
+@reflectiveTest
+class InstanceMemberInferenceClassTaskResolutionTest extends TaskResolutionTest
+ with InstanceMemberInferenceClassMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart
new file mode 100644
index 0000000..387e166
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart
@@ -0,0 +1,296 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+import 'resolution.dart';
+import 'task_resolution.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(InstanceMemberInferenceMixinDriverResolutionTest);
+ defineReflectiveTests(InstanceMemberInferenceMixinTaskResolutionTest);
+ });
+}
+
+@reflectiveTest
+class InstanceMemberInferenceMixinDriverResolutionTest
+ extends DriverResolutionTest with InstanceMemberInferenceMixinMixin {}
+
+abstract class InstanceMemberInferenceMixinMixin implements ResolutionTest {
+ test_invalid_inheritanceCycle() async {
+ addTestFile('''
+mixin A on C {}
+mixin B on A {}
+mixin C on B {}
+''');
+ await resolveTestFile();
+ }
+
+ test_method_parameter_multiple_different() async {
+ addTestFile('''
+class A {
+ foo(int p) => 0;
+}
+class B {
+ foo(double p) => 0;
+}
+mixin M on A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_named_different() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo({int q}) => 0;
+}
+mixin M on A, B {
+ foo({p}) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_named_same() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo({int p}) => 0;
+}
+mixin M on A, B {
+ foo({p}) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeString(p.type, 'int');
+ }
+
+ test_method_parameter_multiple_namedAndRequired() async {
+ addTestFile('''
+class A {
+ foo({int p}) => 0;
+}
+class B {
+ foo(int p) => 0;
+}
+mixin M on A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeDynamic(p.type);
+ }
+
+ test_method_parameter_multiple_optionalAndRequired() async {
+ addTestFile('''
+class A {
+ foo(int p) => 0;
+}
+class B {
+ foo([int p]) => 0;
+}
+mixin M on A, B {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeString(p.type, 'int');
+ }
+
+ test_method_parameter_single_generic() async {
+ addTestFile('''
+class A<E> {
+ foo(E p) => 0;
+}
+mixin M<T> on A<T> {
+ foo(p) => 0;
+}
+''');
+ await resolveTestFile();
+
+ var p = findElement.method('foo', of: 'M').parameters[0];
+ assertElementTypeString(p.type, 'T');
+ }
+
+ test_method_return_multiple_different() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ double foo() => 0.0;
+}
+mixin M on A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_different_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => null;
+}
+class B<E> {
+ E foo() => null;
+}
+mixin M on A<int>, B<double> {
+ foo() => null;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_different_void() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ void foo() => 0;
+}
+mixin M on A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_dynamic() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ foo() => 0;
+}
+mixin M on A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeDynamic(foo.returnType);
+ }
+
+ test_method_return_multiple_same_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => 0;
+}
+class B<E> {
+ E foo() => 0;
+}
+mixin M<T> on A<T>, B<T> {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeString(foo.returnType, 'T');
+ }
+
+ test_method_return_multiple_same_nonVoid() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+class B {
+ int foo() => 0;
+}
+mixin M on A, B {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeString(foo.returnType, 'int');
+ }
+
+ test_method_return_multiple_same_void() async {
+ addTestFile('''
+class A {
+ void foo() {};
+}
+class B {
+ void foo() {};
+}
+mixin M on A, B {
+ foo() {};
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeString(foo.returnType, 'void');
+ }
+
+ test_method_return_single() async {
+ addTestFile('''
+class A {
+ int foo() => 0;
+}
+mixin M on A {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeString(foo.returnType, 'int');
+ }
+
+ test_method_return_single_generic() async {
+ addTestFile('''
+class A<E> {
+ E foo() => 0;
+}
+mixin M<T> on A<T> {
+ foo() => 0;
+}
+''');
+ await resolveTestFile();
+
+ var foo = findElement.method('foo', of: 'M');
+ assertElementTypeString(foo.returnType, 'T');
+ }
+}
+
+@reflectiveTest
+class InstanceMemberInferenceMixinTaskResolutionTest extends TaskResolutionTest
+ with InstanceMemberInferenceMixinMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 69c1580..e01671b 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -79,6 +79,10 @@
expect(type, expected);
}
+ void assertElementTypeDynamic(DartType type) {
+ expect(type, isDynamicType);
+ }
+
void assertElementTypes(List<DartType> types, List<DartType> expected,
{bool ordered = false}) {
if (ordered) {
@@ -88,6 +92,10 @@
}
}
+ void assertElementTypeString(DartType type, String expected) {
+ expect(type.toString(), expected);
+ }
+
void assertEnclosingElement(Element element, Element expectedEnclosing) {
expect(element.enclosingElement, expectedEnclosing);
}
diff --git a/pkg/analyzer/test/src/dart/resolution/test_all.dart b/pkg/analyzer/test/src/dart/resolution/test_all.dart
index b2dee84..d93d42c 100644
--- a/pkg/analyzer/test/src/dart/resolution/test_all.dart
+++ b/pkg/analyzer/test/src/dart/resolution/test_all.dart
@@ -10,6 +10,10 @@
import 'for_in_test.dart' as for_in_test;
import 'import_prefix_test.dart' as import_prefix_test;
import 'instance_creation_test.dart' as instance_creation_test;
+import 'instance_member_inference_class_test.dart'
+ as instance_member_inference_class_test;
+import 'instance_member_inference_mixin_test.dart'
+ as instance_member_inference_mixin_test;
import 'mixin_test.dart' as mixin_test;
main() {
@@ -20,6 +24,8 @@
for_in_test.main();
import_prefix_test.main();
instance_creation_test.main();
+ instance_member_inference_class_test.main();
+ instance_member_inference_mixin_test.main();
mixin_test.main();
}, name: 'resolution');
}
diff --git a/pkg/analyzer/test/src/task/strong_mode_driver_test.dart b/pkg/analyzer/test/src/task/strong_mode_driver_test.dart
deleted file mode 100644
index e459d9e..0000000
--- a/pkg/analyzer/test/src/task/strong_mode_driver_test.dart
+++ /dev/null
@@ -1,19 +0,0 @@
-// 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.
-
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-import 'strong_mode_test.dart';
-
-main() {
- defineReflectiveSuite(() {
- defineReflectiveTests(InstanceMemberInferrerTest_Driver);
- });
-}
-
-@reflectiveTest
-class InstanceMemberInferrerTest_Driver extends InstanceMemberInferrerTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analyzer/test/src/task/strong_mode_test.dart b/pkg/analyzer/test/src/task/strong_mode_test.dart
index b0cec78..cbf2625 100644
--- a/pkg/analyzer/test/src/task/strong_mode_test.dart
+++ b/pkg/analyzer/test/src/task/strong_mode_test.dart
@@ -5,9 +5,6 @@
import 'dart:async';
import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
-import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/task/strong_mode.dart';
import 'package:test/test.dart';
@@ -17,438 +14,12 @@
main() {
defineReflectiveSuite(() {
- defineReflectiveTests(InstanceMemberInferrerTest);
defineReflectiveTests(SetFieldTypeTest);
defineReflectiveTests(VariableGathererTest);
});
}
@reflectiveTest
-class InstanceMemberInferrerTest extends ResolverTestCase {
- InstanceMemberInferrer createInferrer(LibraryElement library) {
- AnalysisContext context = library.context;
- var inheritanceManager = new InheritanceManager(library);
- return new InstanceMemberInferrer(
- context.typeProvider, (_) => inheritanceManager,
- typeSystem: context.typeSystem);
- }
-
- /**
- * Add a source with the given [content] and return the result of resolving
- * the source.
- */
- Future<CompilationUnitElement> resolve(String content) async {
- Source source = addNamedSource('/test.dart', content);
- if (enableNewAnalysisDriver) {
- var analysisResult = await computeAnalysisResult(source);
- return analysisResult.unit.declaredElement;
- } else {
- return analysisContext
- .resolveCompilationUnit2(source, source)
- .declaredElement;
- }
- }
-
- test_inferCompilationUnit_invalid_inheritanceCycle() async {
- CompilationUnitElement unit = await resolve('''
-class A extends C {}
-class B extends A {}
-class C extends B {}
-''');
- _runInferrer(unit);
- }
-
- test_inferCompilationUnit_method_parameter_multiple_different() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- $methodName(int p) => 0;
-}
-class B {
- $methodName(double p) => 0;
-}
-class C implements A, B {
- $methodName(p) => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- expect(parameterC.type.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(parameterC.type.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_parameter_multiple_named_different() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- $methodName({int p}) => 0;
-}
-class B {
- $methodName({int q}) => 0;
-}
-class C implements A, B {
- $methodName({p}) => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- expect(parameterC.type.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(parameterC.type.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_parameter_multiple_named_same() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- $methodName({int p}) => 0;
-}
-class B {
- $methodName({int p}) => 0;
-}
-class C implements A, B {
- $methodName({p}) => 0;
-}
-''');
- ClassElement classA = unit.getType('A');
- MethodElement methodA = classA.getMethod(methodName);
- ParameterElement parameterA = methodA.parameters[0];
- DartType expectedType = parameterA.type;
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- if (previewDart2) {
- expect(parameterC.type.isDynamic, isFalse);
- } else {
- expect(parameterC.type.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(parameterC.type, expectedType);
- }
-
- test_inferCompilationUnit_method_parameter_multiple_namedAndRequired() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- $methodName({int p}) => 0;
-}
-class B {
- $methodName(int p) => 0;
-}
-class C implements A, B {
- $methodName(p) => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- expect(parameterC.type.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(parameterC.type.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_parameter_multiple_optionalAndRequired() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- $methodName(int p) => 0;
-}
-class B {
- $methodName([int p]) => 0;
-}
-class C implements A, B {
- $methodName(p) => 0;
-}
-''');
- ClassElement classA = unit.getType('A');
- MethodElement methodA = classA.getMethod(methodName);
- ParameterElement parameterA = methodA.parameters[0];
- DartType expectedType = parameterA.type;
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- if (previewDart2) {
- expect(parameterC.type.isDynamic, isFalse);
- } else {
- expect(parameterC.type.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(parameterC.type, expectedType);
- }
-
- test_inferCompilationUnit_method_parameter_single_generic() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A<E> {
- $methodName(E p) => 0;
-}
-class C<E> implements A<E> {
- $methodName(p) => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- DartType typeCE = classC.typeParameters[0].type;
- MethodElement methodC = classC.getMethod(methodName);
- ParameterElement parameterC = methodC.parameters[0];
- if (previewDart2) {
- expect(parameterC.type.isDynamic, isFalse);
- } else {
- expect(parameterC.type.isDynamic, isTrue);
- }
- expect(methodC.type.typeArguments, [typeCE]);
-
- _runInferrer(unit);
-
- expect(parameterC.type, classC.typeParameters[0].type);
- expect(methodC.type.typeArguments, [typeCE],
- reason: 'function type should still have type arguments');
- }
-
- test_inferCompilationUnit_method_return_multiple_different() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- int $methodName() => 0;
-}
-class B {
- double $methodName() => 0.0;
-}
-class C implements A, B {
- $methodName() => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- expect(methodC.returnType.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_return_multiple_different_generic() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A<E> {
- E $methodName() => null;
-}
-class B<E> {
- E $methodName() => null;
-}
-class C implements A<int>, B<double> {
- $methodName() => null;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- expect(methodC.returnType.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_return_multiple_dynamic() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- int $methodName() => 0;
-}
-class B {
- $methodName() => 0;
-}
-class C implements A, B {
- $methodName() => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- expect(methodC.returnType.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_return_multiple_same_generic() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A<E> {
- E $methodName() => 0;
-}
-class B<E> {
- E $methodName() => 0;
-}
-class C<E> implements A<E>, B<E> {
- $methodName() => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- if (previewDart2) {
- expect(methodC.returnType.isDynamic, isFalse);
- } else {
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(methodC.returnType, classC.typeParameters[0].type);
- }
-
- test_inferCompilationUnit_method_return_multiple_same_nonVoid() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- int $methodName() => 0;
-}
-class B {
- int $methodName() => 0;
-}
-class C implements A, B {
- $methodName() => 0;
-}
-''');
- ClassElement classA = unit.getType('A');
- MethodElement methodA = classA.getMethod(methodName);
- DartType expectedType = methodA.returnType;
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- if (previewDart2) {
- expect(methodC.returnType.isDynamic, isFalse);
- } else {
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(methodC.returnType, expectedType);
- }
-
- test_inferCompilationUnit_method_return_multiple_same_void() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- void $methodName() {};
-}
-class B {
- void $methodName() {};
-}
-class C implements A, B {
- $methodName() {};
-}
-''');
- ClassElement classA = unit.getType('A');
- MethodElement methodA = classA.getMethod(methodName);
- DartType expectedType = methodA.returnType;
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- if (previewDart2) {
- expect(methodC.returnType.isDynamic, isFalse);
- } else {
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(methodC.returnType, expectedType);
- }
-
- test_inferCompilationUnit_method_return_multiple_void() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- int $methodName() => 0;
-}
-class B {
- void $methodName() => 0;
-}
-class C implements A, B {
- $methodName() => 0;
-}
-''');
- ClassElement classC = unit.getType('C');
- MethodElement methodC = classC.getMethod(methodName);
- expect(methodC.returnType.isDynamic, isTrue);
-
- _runInferrer(unit);
-
- expect(methodC.returnType.isDynamic, isTrue);
- }
-
- test_inferCompilationUnit_method_return_single() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A {
- int $methodName() => 0;
-}
-class B extends A {
- $methodName() => 0;
-}
-''');
- ClassElement classA = unit.getType('A');
- MethodElement methodA = classA.getMethod(methodName);
- ClassElement classB = unit.getType('B');
- MethodElement methodB = classB.getMethod(methodName);
- if (previewDart2) {
- expect(methodB.returnType.isDynamic, isFalse);
- } else {
- expect(methodB.returnType.isDynamic, isTrue);
- }
-
- _runInferrer(unit);
-
- expect(methodB.returnType, methodA.returnType);
- }
-
- test_inferCompilationUnit_method_return_single_generic() async {
- String methodName = 'm';
- CompilationUnitElement unit = await resolve('''
-class A<E> {
- E $methodName() => 0;
-}
-class B<E> extends A<E> {
- $methodName() => 0;
-}
-''');
- ClassElement classB = unit.getType('B');
- DartType typeBE = classB.typeParameters[0].type;
- MethodElement methodB = classB.getMethod(methodName);
- if (previewDart2) {
- expect(methodB.returnType.isDynamic, isFalse);
- } else {
- expect(methodB.returnType.isDynamic, isTrue);
- }
- expect(methodB.type.typeArguments, [typeBE]);
-
- _runInferrer(unit);
-
- expect(methodB.returnType, classB.typeParameters[0].type);
- expect(methodB.type.typeArguments, [typeBE],
- reason: 'function type should still have type arguments');
- }
-
- InstanceMemberInferrer _runInferrer(CompilationUnitElement unit) {
- InstanceMemberInferrer inferrer = createInferrer(unit.library);
- inferrer.inferCompilationUnit(unit);
- return inferrer;
- }
-}
-
-@reflectiveTest
class SetFieldTypeTest extends ResolverTestCase {
test_setter_withoutParameter() async {
Source source = addSource('''
diff --git a/pkg/analyzer/test/src/task/test_all.dart b/pkg/analyzer/test/src/task/test_all.dart
index 92e46d2..8d02ae5 100644
--- a/pkg/analyzer/test/src/task/test_all.dart
+++ b/pkg/analyzer/test/src/task/test_all.dart
@@ -18,7 +18,6 @@
import 'options_test.dart' as options_test;
import 'options_work_manager_test.dart' as options_work_manager_test;
import 'strong/test_all.dart' as strong_mode_test_all;
-import 'strong_mode_driver_test.dart' as strong_mode_driver_test;
import 'strong_mode_test.dart' as strong_mode_test;
import 'yaml_test.dart' as yaml_test;
@@ -37,7 +36,6 @@
options_test.main();
options_work_manager_test.main();
strong_mode_test_all.main();
- strong_mode_driver_test.main();
strong_mode_test.main();
yaml_test.main();
}, name: 'task');
