blob: 5d5874a5eddcdd7c6a549d56b8a132e36af0a39d [file] [log] [blame]
// Copyright (c) 2015, 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.
// TODO(jmesserly): this file needs to be refactored, it's a port from
// package:dev_compiler's tests
/// Tests for type inference.
library analyzer.test.src.task.strong.inferred_type_test;
import 'package:analyzer/dart/element/element.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'strong_test_helper.dart' as helper;
void main() {
defineReflectiveSuite(() {
defineReflectiveTests(InferredTypeTest);
});
}
abstract class InferredTypeMixin {
/**
* If `true` then types of local elements may be checked.
*/
bool get mayCheckTypesOfLocals;
/**
* Add a new file with the given [name] and [content].
*/
void addFile(String content, {String name: '/main.dart'});
/**
* Add the file, process it (resolve, validate, etc) and return the resolved
* unit element.
*/
CompilationUnitElement checkFile(String content);
void test_asyncClosureReturnType_flatten() {
var mainUnit = checkFile('''
import 'dart:async';
Future<int> futureInt = null;
var f = () => futureInt;
var g = () async => futureInt;
''');
var futureInt = mainUnit.topLevelVariables[0];
expect(futureInt.name, 'futureInt');
expect(futureInt.type.toString(), 'Future<int>');
var f = mainUnit.topLevelVariables[1];
expect(f.name, 'f');
expect(f.type.toString(), '() → Future<int>');
var g = mainUnit.topLevelVariables[2];
expect(g.name, 'g');
expect(g.type.toString(), '() → Future<int>');
}
void test_asyncClosureReturnType_future() {
var mainUnit = checkFile('var f = () async => 0;');
var f = mainUnit.topLevelVariables[0];
expect(f.name, 'f');
expect(f.type.toString(), '() → Future<int>');
}
void test_blockBodiedLambdas_async_allReturnsAreFutures() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() async {
if (new Random().nextBool()) {
return new Future<int>.value(1);
} else {
return new Future<double>.value(2.0);
}
};
Future<num> g = f();
Future<int> h = /*info:ASSIGNMENT_CAST*/f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_async_allReturnsAreFutures_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() async {
if (new Random().nextBool()) {
return new Future<int>.value(1);
} else {
return new Future<double>.value(2.0);
}
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_async_allReturnsAreValues() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() async {
if (new Random().nextBool()) {
return 1;
} else {
return 2.0;
}
};
Future<num> g = f();
Future<int> h = /*info:ASSIGNMENT_CAST*/f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_async_allReturnsAreValues_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() async {
if (new Random().nextBool()) {
return 1;
} else {
return 2.0;
}
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_async_mixOfValuesAndFutures() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() async {
if (new Random().nextBool()) {
return new Future<int>.value(1);
} else {
return 2.0;
}
};
Future<num> g = f();
Future<int> h = /*info:ASSIGNMENT_CAST*/f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_async_mixOfValuesAndFutures_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
import 'dart:math' show Random;
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() async {
if (new Random().nextBool()) {
return new Future<int>.value(1);
} else {
return 2.0;
}
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Future<num>');
}
void test_blockBodiedLambdas_asyncStar() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() async* {
yield 1;
Stream<double> s;
yield* s;
};
Stream<num> g = f();
Stream<int> h = /*info:ASSIGNMENT_CAST*/f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Stream<num>');
}
void test_blockBodiedLambdas_asyncStar_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() async* {
yield 1;
Stream<double> s;
yield* s;
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Stream<num>');
}
void test_blockBodiedLambdas_basic() {
checkFile(r'''
test1() {
List<int> o;
var y = o.map(/*info:INFERRED_TYPE_CLOSURE,info:INFERRED_TYPE_CLOSURE*/(x) { return x + 1; });
Iterable<int> z = y;
}
''');
}
void test_blockBodiedLambdas_basic_topLevel() {
checkFile(r'''
List<int> o;
var y = o.map(/*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/(x) { return x + 1; });
Iterable<int> z = y;
''');
}
void test_blockBodiedLambdas_doesNotInferBottom_async() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
main() async {
var f = () async { return null; };
Future y = f();
Future<String> z = /*warning:DOWN_CAST_COMPOSITE*/f();
String s = /*info:DYNAMIC_CAST*/await f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Future<dynamic>');
}
void test_blockBodiedLambdas_doesNotInferBottom_async_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
var f = /*warning:UNSAFE_BLOCK_CLOSURE_INFERENCE,info:INFERRED_TYPE_CLOSURE*/() async { return null; };
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Future<dynamic>');
}
void test_blockBodiedLambdas_doesNotInferBottom_asyncStar() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
import 'dart:async';
main() async {
var f = () async* { yield null; };
Stream y = f();
Stream<String> z = /*warning:DOWN_CAST_COMPOSITE*/f();
String s = /*info:DYNAMIC_CAST*/await f().first;
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Stream<dynamic>');
}
void test_blockBodiedLambdas_doesNotInferBottom_asyncStar_topLevel() {
var mainUnit = checkFile(r'''
import 'dart:async';
var f = /*warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() async* { yield null; };
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Stream<dynamic>');
}
void test_blockBodiedLambdas_doesNotInferBottom_sync() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
var h = null;
void foo(int f(Object _)) {}
main() {
var f = (Object x) { return null; };
String y = /*info:DYNAMIC_CAST*/f(42);
f = /*info:INFERRED_TYPE_CLOSURE*/(x) => 'hello';
foo(/*info:INFERRED_TYPE_CLOSURE*/(x) { return null; });
foo(/*info:INFERRED_TYPE_CLOSURE*/(x) { throw "not implemented"; });
}
''');
var f = mainUnit.functions[1].localVariables[0];
expect(f.type.toString(), '(Object) → dynamic');
}
void test_blockBodiedLambdas_doesNotInferBottom_sync_topLevel() {
var mainUnit = checkFile(r'''
var f = (Object x) { return null; };
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '(Object) → dynamic');
}
void test_blockBodiedLambdas_doesNotInferBottom_syncStar() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
main() {
var f = () sync* { yield null; };
Iterable y = f();
Iterable<String> z = /*warning:DOWN_CAST_COMPOSITE*/f();
String s = /*info:DYNAMIC_CAST*/f().first;
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Iterable<dynamic>');
}
void test_blockBodiedLambdas_doesNotInferBottom_syncStar_topLevel() {
var mainUnit = checkFile(r'''
var f = /*warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() sync* { yield null; };
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Iterable<dynamic>');
}
void test_blockBodiedLambdas_downwardsIncompatibleWithUpwardsInference() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
main() {
String f() => null;
var g = f;
g = /*info:INFERRED_TYPE_CLOSURE*/() { return /*error:RETURN_OF_INVALID_TYPE*/1; };
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → String');
}
void
test_blockBodiedLambdas_downwardsIncompatibleWithUpwardsInference_topLevel() {
var mainUnit = checkFile(r'''
String f() => null;
var g = f;
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → String');
}
void test_blockBodiedLambdas_LUB() {
checkFile(r'''
import 'dart:math' show Random;
test2() {
List<num> o;
var y = o.map(/*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*/(x) {
if (new Random().nextBool()) {
return x.toInt() + 1;
} else {
return x.toDouble();
}
});
Iterable<num> w = y;
Iterable<int> z = /*info:ASSIGNMENT_CAST*/y;
}
''');
}
void test_blockBodiedLambdas_LUB_topLevel() {
checkFile(r'''
import 'dart:math' show Random;
List<num> o;
var y = o.map(/*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/(x) {
if (new Random().nextBool()) {
return x.toInt() + 1;
} else {
return x.toDouble();
}
});
Iterable<num> w = y;
Iterable<int> z = /*info:ASSIGNMENT_CAST*/y;
''');
}
void test_blockBodiedLambdas_nestedLambdas() {
if (!mayCheckTypesOfLocals) {
return;
}
// Original feature request: https://github.com/dart-lang/sdk/issues/25487
var mainUnit = checkFile(r'''
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() {
return /*info:INFERRED_TYPE_CLOSURE*/(int x) { return 2.0 * x; };
};
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → (int) → double');
}
void test_blockBodiedLambdas_nestedLambdas_topLevel() {
// Original feature request: https://github.com/dart-lang/sdk/issues/25487
var mainUnit = checkFile(r'''
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() {
return /*info:INFERRED_TYPE_CLOSURE*/(int x) { return 2.0 * x; };
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → (int) → double');
}
void test_blockBodiedLambdas_noReturn() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
test1() {
List<int> o;
var y = o.map(/*info:INFERRED_TYPE_CLOSURE*/(x) { });
Iterable<int> z = /*warning:DOWN_CAST_COMPOSITE*/y;
}
''');
var f = mainUnit.functions[0].localVariables[1];
expect(f.type.toString(), 'Iterable<dynamic>');
}
void test_blockBodiedLambdas_noReturn_topLevel() {
var mainUnit = checkFile(r'''
final List<int> o = <int>[];
var y = o.map((x) { });
''');
var f = mainUnit.topLevelVariables[1];
expect(f.type.toString(), 'Iterable<dynamic>');
}
void test_blockBodiedLambdas_syncStar() {
if (!mayCheckTypesOfLocals) {
return;
}
var mainUnit = checkFile(r'''
main() {
var f = /*info:INFERRED_TYPE_CLOSURE*/() sync* {
yield 1;
yield* /*info:INFERRED_TYPE_LITERAL*/[3, 4.0];
};
Iterable<num> g = f();
Iterable<int> h = /*info:ASSIGNMENT_CAST*/f();
}
''');
var f = mainUnit.functions[0].localVariables[0];
expect(f.type.toString(), '() → Iterable<num>');
}
void test_blockBodiedLambdas_syncStar_topLevel() {
var mainUnit = checkFile(r'''
var f = /*info:INFERRED_TYPE_CLOSURE,warning:UNSAFE_BLOCK_CLOSURE_INFERENCE*/() sync* {
yield 1;
yield* /*info:INFERRED_TYPE_LITERAL*/[3, 4.0];
};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → Iterable<num>');
}
void test_bottom() {
// When a type is inferred from the expression `null`, the inferred type is
// `dynamic`, but the inferred type of the initializer is `bottom`.
// TODO(paulberry): Is this intentional/desirable?
var mainUnit = checkFile('''
var v = null;
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'dynamic');
expect(v.initializer.type.toString(), '() → Null');
}
void test_bottom_inClosure() {
// When a closure's return type is inferred from the expression `null`, the
// inferred type is `dynamic`.
var mainUnit = checkFile('''
var v = () => null;
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), '() → dynamic');
expect(v.initializer.type.toString(), '() → () → dynamic');
}
void test_canInferAlsoFromStaticAndInstanceFieldsFlagOn() {
addFile(
'''
import 'b.dart';
class A {
static final a1 = B.b1;
final a2 = new B().b2;
}
''',
name: '/a.dart');
addFile(
'''
class B {
static final b1 = 1;
final b2 = 1;
}
''',
name: '/b.dart');
checkFile('''
import "a.dart";
test1() {
int x = 0;
// inference in A now works.
x = A.a1;
x = new A().a2;
}
''');
}
void test_circularReference_viaClosures() {
var mainUnit = checkFile('''
var x = () => y;
var y = () => x;
''');
var x = mainUnit.topLevelVariables[0];
var y = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(y.name, 'y');
expect(x.type.toString(), 'dynamic');
expect(y.type.toString(), 'dynamic');
}
void test_circularReference_viaClosures_initializerTypes() {
var mainUnit = checkFile('''
var x = () => y;
var y = () => x;
''');
var x = mainUnit.topLevelVariables[0];
var y = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(y.name, 'y');
expect(x.initializer.returnType.toString(), '() → dynamic');
expect(y.initializer.returnType.toString(), '() → dynamic');
}
void test_conflictsCanHappen() {
checkFile('''
class I1 {
int x;
}
class I2 extends I1 {
int y;
}
class A {
final I1 a = null;
}
class B {
final I2 a = null;
}
class C1 implements A, B {
/*error:INVALID_METHOD_OVERRIDE*/get a => null;
}
// Still ambiguous
class C2 implements B, A {
/*error:INVALID_METHOD_OVERRIDE*/get a => null;
}
''');
}
void test_conflictsCanHappen2() {
checkFile('''
class I1 {
int x;
}
class I2 {
int y;
}
class I3 implements I1, I2 {
int x;
int y;
}
class A {
final I1 a = null;
}
class B {
final I2 a = null;
}
class C1 implements A, B {
I3 get a => null;
}
class C2 implements A, B {
/*error:INVALID_METHOD_OVERRIDE*/get a => null;
}
''');
}
void test_constructors_downwardsWithConstraint() {
// Regression test for https://github.com/dart-lang/sdk/issues/26431
checkFile(r'''
class A {}
class B extends A {}
class Foo<T extends A> {}
void main() {
Foo<B> foo = /*info:INFERRED_TYPE_ALLOCATION*/new Foo();
}
''');
}
@failingTest
void test_constructors_inferenceFBounded() {
// Regression for https://github.com/dart-lang/sdk/issues/26990
var unit = checkFile('''
class Clonable<T> {}
class Pair<T extends Clonable<T>, U extends Clonable<U>> {
T t;
U u;
Pair(this.t, this.u);
Pair._();
Pair<U, T> get reversed => /*info:INFERRED_TYPE_ALLOCATION*/new Pair(u, t);
}
final x = /*info:INFERRED_TYPE_ALLOCATION*/new Pair._();
''');
var x = unit.topLevelVariables[0];
expect(x.type.toString(), 'Pair<Clonable<dynamic>, Clonable<dynamic>>');
}
void test_constructors_inferFromArguments() {
var unit = checkFile('''
class C<T> {
T t;
C(this.t);
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C(42);
num y;
C<int> c_int = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/C(/*info:DOWN_CAST_IMPLICIT*/y);
// These hints are not reported because we resolve with a null error listener.
C<num> c_num = /*pass should be info:INFERRED_TYPE_ALLOCATION*/new C(123);
C<num> c_num2 = (/*pass should be info:INFERRED_TYPE_ALLOCATION*/new C(456))
..t = /*error:INVALID_ASSIGNMENT*/1.0;
// Down't infer from explicit dynamic.
var c_dynamic = new C<dynamic>(42);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
var vars = unit.topLevelVariables;
expect(vars[0].type.toString(), 'C<int>');
expect(vars.firstWhere((e) => e.name == 'c_int').type.toString(), 'C<int>');
expect(vars.firstWhere((e) => e.name == 'c_num').type.toString(), 'C<num>');
expect(vars.firstWhere((e) => e.name == 'c_dynamic').type.toString(),
'C<dynamic>');
}
void test_constructors_inferFromArguments_const() {
var unit = checkFile('''
class C<T> {
final T t;
const C(this.t);
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/const C(42);
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_inferFromArguments_constWithUpperBound() {
// Regression for https://github.com/dart-lang/sdk/issues/26993
checkFile('''
class C<T extends num> {
final T x;
const C(this.x);
}
class D<T extends num> {
const D();
}
void f() {
const c = /*info:INFERRED_TYPE_ALLOCATION*/const C(0);
const D<int> d = /*info:INFERRED_TYPE_ALLOCATION*/const D();
}
''');
}
void test_constructors_inferFromArguments_factory() {
var unit = checkFile('''
class C<T> {
T t;
C._();
factory C(T t) {
var x = new C<T>._();
x.t = t;
return x;
}
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C(42);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_inferFromArguments_factory_callsConstructor() {
checkFile(r'''
class A<T> {
A<T> f = /*info:INFERRED_TYPE_ALLOCATION*/new A();
A();
factory A.factory() => /*info:INFERRED_TYPE_ALLOCATION*/new A();
A<T> m() => /*info:INFERRED_TYPE_ALLOCATION*/new A();
}
''');
}
void test_constructors_inferFromArguments_named() {
var unit = checkFile('''
class C<T> {
T t;
C.named(List<T> t);
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C.named(<int>[]);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_inferFromArguments_namedFactory() {
var unit = checkFile('''
class C<T> {
T t;
C();
factory C.named(T t) {
var x = new C<T>();
x.t = t;
return x;
}
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C.named(42);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_inferFromArguments_redirecting() {
var unit = checkFile('''
class C<T> {
T t;
C(this.t);
C.named(List<T> t) : this(t[0]);
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C.named(<int>[42]);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_inferFromArguments_redirectingFactory() {
var unit = checkFile('''
abstract class C<T> {
T get t;
void set t(T x);
factory C(T t) = CImpl<T>;
}
class CImpl<T> implements C<T> {
T t;
CImpl(this.t);
}
var x = /*info:INFERRED_TYPE_ALLOCATION*/new C(42);
main() {
x.t = /*error:INVALID_ASSIGNMENT*/'hello';
}
''');
expect(unit.topLevelVariables[0].type.toString(), 'C<int>');
}
void test_constructors_reverseTypeParameters() {
// Regression for https://github.com/dart-lang/sdk/issues/26990
checkFile('''
class Pair<T, U> {
T t;
U u;
Pair(this.t, this.u);
Pair<U, T> get reversed => /*info:INFERRED_TYPE_ALLOCATION*/new Pair(u, t);
}
''');
}
void test_doNotInferOverriddenFieldsThatExplicitlySayDynamic_infer() {
checkFile('''
class A {
final int x = 2;
}
class B implements A {
/*error:INVALID_METHOD_OVERRIDE*/dynamic get x => 3;
}
foo() {
String y = /*info:DYNAMIC_CAST*/new B().x;
int z = /*info:DYNAMIC_CAST*/new B().x;
}
''');
}
void test_dontInferFieldTypeWhenInitializerIsNull() {
checkFile('''
var x = null;
var y = 3;
class A {
static var x = null;
static var y = 3;
var x2 = null;
var y2 = 3;
}
test() {
x = "hi";
y = /*error:INVALID_ASSIGNMENT*/"hi";
A.x = "hi";
A.y = /*error:INVALID_ASSIGNMENT*/"hi";
new A().x2 = "hi";
new A().y2 = /*error:INVALID_ASSIGNMENT*/"hi";
}
''');
}
void test_dontInferTypeOnDynamic() {
checkFile('''
test() {
dynamic x = 3;
x = "hi";
}
''');
}
void test_dontInferTypeWhenInitializerIsNull() {
checkFile('''
test() {
var x = null;
x = "hi";
x = 3;
}
''');
}
void test_downwardInference_miscellaneous() {
checkFile('''
typedef T Function2<S, T>(S x);
class A<T> {
Function2<T, T> x;
A(this.x);
}
void main() {
{ // Variables, nested literals
var x = "hello";
var y = 3;
void f(List<Map<int, String>> l) {};
f(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/{y: x}]);
}
{
int f(int x) => 0;
A<int> a = /*info:INFERRED_TYPE_ALLOCATION*/new A(f);
}
}
''');
}
void test_downwardsInferenceAnnotations() {
checkFile('''
class Foo {
const Foo(List<String> l);
const Foo.named(List<String> l);
}
@Foo(/*info:INFERRED_TYPE_LITERAL*/const [])
class Bar {}
@Foo.named(/*info:INFERRED_TYPE_LITERAL*/const [])
class Baz {}
''');
}
void test_downwardsInferenceAssignmentStatements() {
checkFile('''
void main() {
List<int> l;
l = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"];
l = (l = /*info:INFERRED_TYPE_LITERAL*/[1]);
}
''');
}
void test_downwardsInferenceAsyncAwait() {
checkFile('''
import 'dart:async';
Future test() async {
dynamic d;
List<int> l0 = await /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*info:DYNAMIC_CAST*/d];
List<int> l1 = await /*info:INFERRED_TYPE_ALLOCATION*/new Future.value([d]);
}
''');
}
void test_downwardsInferenceForEach() {
checkFile('''
import 'dart:async';
abstract class MyStream<T> extends Stream<T> {
factory MyStream() => null;
}
Future main() async {
for(int x in /*info:INFERRED_TYPE_LITERAL*/[1, 2, 3]) {}
await for(int x in /*info:INFERRED_TYPE_ALLOCATION*/new MyStream()) {}
}
''');
}
void test_downwardsInferenceInitializingFormalDefaultFormal() {
checkFile('''
typedef T Function2<S, T>([S x]);
class Foo {
List<int> x;
Foo([this.x = /*info:INFERRED_TYPE_LITERAL*/const [1]]);
Foo.named([List<int> x = /*info:INFERRED_TYPE_LITERAL*/const [1]]);
}
void f([List<int> l = /*info:INFERRED_TYPE_LITERAL*/const [1]]) {}
// We do this inference in an early task but don't preserve the infos.
Function2<List<int>, String> g = /*pass should be info:INFERRED_TYPE_CLOSURE*/([llll = /*info:INFERRED_TYPE_LITERAL*/const [1]]) => "hello";
''');
}
void test_downwardsInferenceOnConstructorArguments_inferDownwards() {
checkFile('''
class F0 {
F0(List<int> a) {}
}
class F1 {
F1({List<int> a}) {}
}
class F2 {
F2(Iterable<int> a) {}
}
class F3 {
F3(Iterable<Iterable<int>> a) {}
}
class F4 {
F4({Iterable<Iterable<int>> a}) {}
}
void main() {
new F0(/*info:INFERRED_TYPE_LITERAL*/[]);
new F0(/*info:INFERRED_TYPE_LITERAL*/[3]);
new F0(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F0(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello",
3]);
new F1(a: /*info:INFERRED_TYPE_LITERAL*/[]);
new F1(a: /*info:INFERRED_TYPE_LITERAL*/[3]);
new F1(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F1(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
new F2(/*info:INFERRED_TYPE_LITERAL*/[]);
new F2(/*info:INFERRED_TYPE_LITERAL*/[3]);
new F2(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F2(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
new F3(/*info:INFERRED_TYPE_LITERAL*/[]);
new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F4(a: /*info:INFERRED_TYPE_LITERAL*/[]);
new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
}
''');
}
void test_downwardsInferenceOnFunctionArguments_inferDownwards() {
checkFile('''
void f0(List<int> a) {}
void f1({List<int> a}) {}
void f2(Iterable<int> a) {}
void f3(Iterable<Iterable<int>> a) {}
void f4({Iterable<Iterable<int>> a}) {}
void main() {
f0(/*info:INFERRED_TYPE_LITERAL*/[]);
f0(/*info:INFERRED_TYPE_LITERAL*/[3]);
f0(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
f0(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
f1(a: /*info:INFERRED_TYPE_LITERAL*/[]);
f1(a: /*info:INFERRED_TYPE_LITERAL*/[3]);
f1(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
f1(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
f2(/*info:INFERRED_TYPE_LITERAL*/[]);
f2(/*info:INFERRED_TYPE_LITERAL*/[3]);
f2(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
f2(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
f3(/*info:INFERRED_TYPE_LITERAL*/[]);
f3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
f3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
f3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"], /*info:INFERRED_TYPE_LITERAL*/[3]]);
f4(a: /*info:INFERRED_TYPE_LITERAL*/[]);
f4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
f4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
f4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"], /*info:INFERRED_TYPE_LITERAL*/[3]]);
}
''');
}
void test_downwardsInferenceOnFunctionExpressions() {
checkFile('''
typedef T Function2<S, T>(S x);
void main () {
{
Function2<int, String> l0 = /*info:INFERRED_TYPE_CLOSURE*/(int x) => null;
Function2<int, String> l1 = (int x) => "hello";
Function2<int, String> l2 = /*error:INVALID_ASSIGNMENT*/(String x) => "hello";
Function2<int, String> l3 = /*error:INVALID_ASSIGNMENT*/(int x) => 3;
Function2<int, String> l4 = /*info:INFERRED_TYPE_CLOSURE*/(int x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
}
{
Function2<int, String> l0 = /*info:INFERRED_TYPE_CLOSURE*/(x) => null;
Function2<int, String> l1 = /*info:INFERRED_TYPE_CLOSURE*/(x) => "hello";
Function2<int, String> l2 = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*/(x) => 3;
Function2<int, String> l3 = /*info:INFERRED_TYPE_CLOSURE*/(x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
Function2<int, String> l4 = /*info:INFERRED_TYPE_CLOSURE*/(x) {return /*error:RETURN_OF_INVALID_TYPE*/x;};
}
{
Function2<int, List<String>> l0 = /*info:INFERRED_TYPE_CLOSURE*/(int x) => null;
Function2<int, List<String>> l1 = (int x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
Function2<int, List<String>> l2 = /*error:INVALID_ASSIGNMENT*/(String x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
Function2<int, List<String>> l3 = (int x) => /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];
Function2<int, List<String>> l4 = /*info:INFERRED_TYPE_CLOSURE*/(int x) {return /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];};
}
{
Function2<int, int> l0 = /*info:INFERRED_TYPE_CLOSURE*/(x) => x;
Function2<int, int> l1 = /*info:INFERRED_TYPE_CLOSURE*/(x) => x+1;
Function2<int, String> l2 = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*/(x) => x;
Function2<int, String> l3 = /*info:INFERRED_TYPE_CLOSURE*/(x) => /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/x.substring(3);
Function2<String, String> l4 = /*info:INFERRED_TYPE_CLOSURE*/(x) => x.substring(3);
}
}
''');
}
void test_downwardsInferenceOnFunctionOfTUsingTheT() {
checkFile('''
void main () {
{
T f<T>(T x) => null;
var v1 = f;
v1 = /*info:INFERRED_TYPE_CLOSURE*/<S>(x) => x;
}
{
List<T> f<T>(T x) => null;
var v2 = f;
v2 = /*info:INFERRED_TYPE_CLOSURE*/<S>(x) => /*info:INFERRED_TYPE_LITERAL*/[x];
Iterable<int> r = v2(42);
Iterable<String> s = v2('hello');
Iterable<List<int>> t = v2(<int>[]);
Iterable<num> u = v2(42);
Iterable<num> v = v2<num>(42);
}
}
''');
}
void test_downwardsInferenceOnFunctionOfTUsingTheT_comment() {
checkFile('''
void main () {
{
/*=T*/ f/*<T>*/(/*=T*/ x) => null;
var v1 = f;
v1 = /*info:INFERRED_TYPE_CLOSURE*//*<S>*/(x) => x;
}
{
/*=List<T>*/ f/*<T>*/(/*=T*/ x) => null;
var v2 = f;
v2 = /*info:INFERRED_TYPE_CLOSURE*//*<S>*/(x) => /*info:INFERRED_TYPE_LITERAL*/[x];
Iterable<int> r = v2(42);
Iterable<String> s = v2('hello');
Iterable<List<int>> t = v2(<int>[]);
Iterable<num> u = v2(42);
Iterable<num> v = v2/*<num>*/(42);
}
}
''');
}
void test_downwardsInferenceOnGenericConstructorArguments_inferDownwards() {
checkFile('''
class F0<T> {
F0(List<T> a) {}
}
class F1<T> {
F1({List<T> a}) {}
}
class F2<T> {
F2(Iterable<T> a) {}
}
class F3<T> {
F3(Iterable<Iterable<T>> a) {}
}
class F4<T> {
F4({Iterable<Iterable<T>> a}) {}
}
void main() {
new F0<int>(/*info:INFERRED_TYPE_LITERAL*/[]);
new F0<int>(/*info:INFERRED_TYPE_LITERAL*/[3]);
new F0<int>(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F0<int>(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello",
3]);
new F1<int>(a: /*info:INFERRED_TYPE_LITERAL*/[]);
new F1<int>(a: /*info:INFERRED_TYPE_LITERAL*/[3]);
new F1<int>(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F1<int>(a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
new F2<int>(/*info:INFERRED_TYPE_LITERAL*/[]);
new F2<int>(/*info:INFERRED_TYPE_LITERAL*/[3]);
new F2<int>(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]);
new F2<int>(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3]);
new F3<int>(/*info:INFERRED_TYPE_LITERAL*/[]);
new F3<int>(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F3<int>(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
new F3<int>(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F4<int>(a: /*info:INFERRED_TYPE_LITERAL*/[]);
new F4<int>(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F4<int>(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"]]);
new F4<int>(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F3(/*info:INFERRED_TYPE_LITERAL*/[]);
/*info:INFERRED_TYPE_ALLOCATION*/new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
/*info:INFERRED_TYPE_ALLOCATION*/new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/["hello"]]);
/*info:INFERRED_TYPE_ALLOCATION*/new F3(/*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/["hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
new F4(a: /*info:INFERRED_TYPE_LITERAL*/[]);
/*info:INFERRED_TYPE_ALLOCATION*/new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/[3]]);
/*info:INFERRED_TYPE_ALLOCATION*/new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/["hello"]]);
/*info:INFERRED_TYPE_ALLOCATION*/new F4(a: /*info:INFERRED_TYPE_LITERAL*/[/*info:INFERRED_TYPE_LITERAL*/["hello"],
/*info:INFERRED_TYPE_LITERAL*/[3]]);
}
''');
}
void test_downwardsInferenceOnGenericFunctionExpressions() {
checkFile('''
void main () {
{
String f<S>(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE*/<T>(int x) => null;
v = <T>(int x) => "hello";
v = /*error:INVALID_ASSIGNMENT*/<T>(String x) => "hello";
v = /*error:INVALID_ASSIGNMENT*/<T>(int x) => 3;
v = /*info:INFERRED_TYPE_CLOSURE*/<T>(int x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
}
{
String f<S>(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*/<T>(x) => null;
v = /*info:INFERRED_TYPE_CLOSURE*/<T>(x) => "hello";
v = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*/<T>(x) => 3;
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*/<T>(x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*/<T>(x) {return /*error:RETURN_OF_INVALID_TYPE*/x;};
}
{
List<String> f<S>(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE*/<T>(int x) => null;
v = <T>(int x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
v = /*error:INVALID_ASSIGNMENT*/<T>(String x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
v = <T>(int x) => /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];
v = /*info:INFERRED_TYPE_CLOSURE*/<T>(int x) {return /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];};
}
{
int int2int<S>(int x) => null;
String int2String<T>(int x) => null;
String string2String<T>(String x) => null;
var x = int2int;
x = /*info:INFERRED_TYPE_CLOSURE*/<T>(x) => x;
x = /*info:INFERRED_TYPE_CLOSURE*/<T>(x) => x+1;
var y = int2String;
y = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*/<T>(x) => x;
y = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*/<T>(x) => /*info:DYNAMIC_INVOKE, info:DYNAMIC_CAST*/x.substring(3);
var z = string2String;
z = /*info:INFERRED_TYPE_CLOSURE*/<T>(x) => x.substring(3);
}
}
''');
}
void test_downwardsInferenceOnGenericFunctionExpressions_comment() {
checkFile('''
void main () {
{
String f/*<S>*/(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(int x) => null;
v = /*<T>*/(int x) => "hello";
v = /*error:INVALID_ASSIGNMENT*//*<T>*/(String x) => "hello";
v = /*error:INVALID_ASSIGNMENT*//*<T>*/(int x) => 3;
v = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(int x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
}
{
String f/*<S>*/(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => null;
v = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => "hello";
v = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*//*<T>*/(x) => 3;
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) {return /*error:RETURN_OF_INVALID_TYPE*/3;};
v = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) {return /*error:RETURN_OF_INVALID_TYPE*/x;};
}
{
List<String> f/*<S>*/(int x) => null;
var v = f;
v = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(int x) => null;
v = /*<T>*/(int x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
v = /*error:INVALID_ASSIGNMENT*//*<T>*/(String x) => /*info:INFERRED_TYPE_LITERAL*/["hello"];
v = /*<T>*/(int x) => /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];
v = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(int x) {return /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3];};
}
{
int int2int/*<S>*/(int x) => null;
String int2String/*<T>*/(int x) => null;
String string2String/*<T>*/(String x) => null;
var x = int2int;
x = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => x;
x = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => x+1;
var y = int2String;
y = /*info:INFERRED_TYPE_CLOSURE, error:INVALID_ASSIGNMENT*//*<T>*/(x) => x;
y = /*info:INFERRED_TYPE_CLOSURE, info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => /*info:DYNAMIC_INVOKE, info:DYNAMIC_CAST*/x.substring(3);
var z = string2String;
z = /*info:INFERRED_TYPE_CLOSURE*//*<T>*/(x) => x.substring(3);
}
}
''');
}
void test_downwardsInferenceOnInstanceCreations_inferDownwards() {
checkFile('''
class A<S, T> {
S x;
T y;
A(this.x, this.y);
A.named(this.x, this.y);
}
class B<S, T> extends A<T, S> {
B(S y, T x) : super(x, y);
B.named(S y, T x) : super.named(x, y);
}
class C<S> extends B<S, S> {
C(S a) : super(a, a);
C.named(S a) : super.named(a, a);
}
class D<S, T> extends B<T, int> {
D(T a) : super(a, 3);
D.named(T a) : super.named(a, 3);
}
class E<S, T> extends A<C<S>, T> {
E(T a) : super(null, a);
}
class F<S, T> extends A<S, T> {
F(S x, T y, {List<S> a, List<T> b}) : super(x, y);
F.named(S x, T y, [S a, T b]) : super(a, b);
}
void main() {
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new A(3, "hello");
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new A.named(3, "hello");
A<int, String> a2 = new A<int, String>(3, "hello");
A<int, String> a3 = new A<int, String>.named(3, "hello");
A<int, String> a4 = /*error:INVALID_CAST_NEW_EXPR*/new A<int, dynamic>(3, "hello");
A<int, String> a5 = /*error:INVALID_CAST_NEW_EXPR*/new A<dynamic, dynamic>.named(3, "hello");
}
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER,error:COULD_NOT_INFER*/A(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello",
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER,error:COULD_NOT_INFER*/A.named(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello",
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
}
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new B("hello", 3);
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new B.named("hello", 3);
A<int, String> a2 = new B<String, int>("hello", 3);
A<int, String> a3 = new B<String, int>.named("hello", 3);
A<int, String> a4 = /*error:INVALID_ASSIGNMENT*/new B<String, dynamic>("hello", 3);
A<int, String> a5 = /*error:INVALID_ASSIGNMENT*/new B<dynamic, dynamic>.named("hello", 3);
}
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER,error:COULD_NOT_INFER*/B(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3,
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER,error:COULD_NOT_INFER*/B.named(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3,
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
}
{
A<int, int> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new C(3);
A<int, int> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new C.named(3);
A<int, int> a2 = new C<int>(3);
A<int, int> a3 = new C<int>.named(3);
A<int, int> a4 = /*error:INVALID_ASSIGNMENT*/new C<dynamic>(3);
A<int, int> a5 = /*error:INVALID_ASSIGNMENT*/new C<dynamic>.named(3);
}
{
A<int, int> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/C(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
A<int, int> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/C.named(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
}
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new D("hello");
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new D.named("hello");
A<int, String> a2 = new D<int, String>("hello");
A<int, String> a3 = new D<String, String>.named("hello");
A<int, String> a4 = /*error:INVALID_ASSIGNMENT*/new D<num, dynamic>("hello");
A<int, String> a5 = /*error:INVALID_ASSIGNMENT*/new D<dynamic, dynamic>.named("hello");
}
{
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/D(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/D.named(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
}
{
A<C<int>, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new E("hello");
}
{ // Check named and optional arguments
A<int, String> a0 = /*info:INFERRED_TYPE_ALLOCATION*/new F(3, "hello",
a: /*info:INFERRED_TYPE_LITERAL*/[3],
b: /*info:INFERRED_TYPE_LITERAL*/["hello"]);
A<int, String> a1 = /*info:INFERRED_TYPE_ALLOCATION*/new F(3, "hello",
a: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"],
b: /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/3]);
A<int, String> a2 = /*info:INFERRED_TYPE_ALLOCATION*/new F.named(3, "hello", 3, "hello");
A<int, String> a3 = /*info:INFERRED_TYPE_ALLOCATION*/new F.named(3, "hello");
A<int, String> a4 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER,error:COULD_NOT_INFER*/F.named(3, "hello",
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello", /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/3);
A<int, String> a5 = /*info:INFERRED_TYPE_ALLOCATION*/new /*error:COULD_NOT_INFER*/F.named(3, "hello",
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hello");
}
}
''');
}
void test_downwardsInferenceOnListLiterals_inferDownwards() {
checkFile('''
void foo([List<String> list1 = /*info:INFERRED_TYPE_LITERAL*/const [],
List<String> list2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const [/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/42]]) {
}
void main() {
{
List<int> l0 = /*info:INFERRED_TYPE_LITERAL*/[];
List<int> l1 = /*info:INFERRED_TYPE_LITERAL*/[3];
List<int> l2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"];
List<int> l3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3];
}
{
List<dynamic> l0 = [];
List<dynamic> l1 = /*info:INFERRED_TYPE_LITERAL*/[3];
List<dynamic> l2 = /*info:INFERRED_TYPE_LITERAL*/["hello"];
List<dynamic> l3 = /*info:INFERRED_TYPE_LITERAL*/["hello", 3];
}
{
List<int> l0 = /*error:INVALID_CAST_LITERAL_LIST*/<num>[];
List<int> l1 = /*error:INVALID_CAST_LITERAL_LIST*/<num>[3];
List<int> l2 = /*error:INVALID_CAST_LITERAL_LIST*/<num>[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"];
List<int> l3 = /*error:INVALID_CAST_LITERAL_LIST*/<num>[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3];
}
{
Iterable<int> i0 = /*info:INFERRED_TYPE_LITERAL*/[];
Iterable<int> i1 = /*info:INFERRED_TYPE_LITERAL*/[3];
Iterable<int> i2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"];
Iterable<int> i3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3];
}
{
const List<int> c0 = /*info:INFERRED_TYPE_LITERAL*/const [];
const List<int> c1 = /*info:INFERRED_TYPE_LITERAL*/const [3];
const List<int> c2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const [/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello"];
const List<int> c3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const [/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/"hello", 3];
}
}
''');
}
void test_downwardsInferenceOnListLiterals_inferIfValueTypesMatchContext() {
checkFile(r'''
class DartType {}
typedef void Asserter<T>(T type);
typedef Asserter<T> AsserterBuilder<S, T>(S arg);
Asserter<DartType> _isInt;
Asserter<DartType> _isString;
abstract class C {
static AsserterBuilder<List<Asserter<DartType>>, DartType> assertBOf;
static AsserterBuilder<List<Asserter<DartType>>, DartType> get assertCOf => null;
AsserterBuilder<List<Asserter<DartType>>, DartType> assertAOf;
AsserterBuilder<List<Asserter<DartType>>, DartType> get assertDOf;
method(AsserterBuilder<List<Asserter<DartType>>, DartType> assertEOf) {
assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertBOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertCOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertDOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertEOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
}
}
abstract class G<T> {
AsserterBuilder<List<Asserter<DartType>>, DartType> assertAOf;
AsserterBuilder<List<Asserter<DartType>>, DartType> get assertDOf;
method(AsserterBuilder<List<Asserter<DartType>>, DartType> assertEOf) {
assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
this.assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
this.assertDOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertEOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
}
}
AsserterBuilder<List<Asserter<DartType>>, DartType> assertBOf;
AsserterBuilder<List<Asserter<DartType>>, DartType> get assertCOf => null;
main() {
AsserterBuilder<List<Asserter<DartType>>, DartType> assertAOf;
assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertBOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
assertCOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
C.assertBOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
C.assertCOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
C c;
c.assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
c.assertDOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
G<int> g;
g.assertAOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
g.assertDOf(/*info:INFERRED_TYPE_LITERAL*/[_isInt, _isString]);
}
''');
}
void test_downwardsInferenceOnMapLiterals() {
checkFile('''
void foo([Map<int, String> m1 = /*info:INFERRED_TYPE_LITERAL*/const {1: "hello"},
Map<int, String> m2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const {
// One error is from type checking and the other is from const evaluation.
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE,error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello":
"world"
}]) {
}
void main() {
{
Map<int, String> l0 = /*info:INFERRED_TYPE_LITERAL*/{};
Map<int, String> l1 = /*info:INFERRED_TYPE_LITERAL*/{3: "hello"};
Map<int, String> l2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello": "hello"
};
Map<int, String> l3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
3: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
Map<int, String> l4 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER,error:COULD_NOT_INFER*/{
3: "hello",
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello":
/*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
}
{
Map<dynamic, dynamic> l0 = {};
Map<dynamic, dynamic> l1 = /*info:INFERRED_TYPE_LITERAL*/{3: "hello"};
Map<dynamic, dynamic> l2 = /*info:INFERRED_TYPE_LITERAL*/{"hello": "hello"};
Map<dynamic, dynamic> l3 = /*info:INFERRED_TYPE_LITERAL*/{3: 3};
Map<dynamic, dynamic> l4 = /*info:INFERRED_TYPE_LITERAL*/{3:"hello", "hello": 3};
}
{
Map<dynamic, String> l0 = /*info:INFERRED_TYPE_LITERAL*/{};
Map<dynamic, String> l1 = /*info:INFERRED_TYPE_LITERAL*/{3: "hello"};
Map<dynamic, String> l2 = /*info:INFERRED_TYPE_LITERAL*/{"hello": "hello"};
Map<dynamic, String> l3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
3: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
Map<dynamic, String> l4 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
3: "hello",
"hello": /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
}
{
Map<int, dynamic> l0 = /*info:INFERRED_TYPE_LITERAL*/{};
Map<int, dynamic> l1 = /*info:INFERRED_TYPE_LITERAL*/{3: "hello"};
Map<int, dynamic> l2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello": "hello"
};
Map<int, dynamic> l3 = /*info:INFERRED_TYPE_LITERAL*/{3: 3};
Map<int, dynamic> l4 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{
3:"hello",
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello": 3
};
}
{
Map<int, String> l0 = /*error:INVALID_CAST_LITERAL_MAP*/<num, dynamic>{};
Map<int, String> l1 = /*error:INVALID_CAST_LITERAL_MAP*/<num, dynamic>{3: "hello"};
Map<int, String> l3 = /*error:INVALID_CAST_LITERAL_MAP*/<num, dynamic>{3: 3};
}
{
const Map<int, String> l0 = /*info:INFERRED_TYPE_LITERAL*/const {};
const Map<int, String> l1 = /*info:INFERRED_TYPE_LITERAL*/const {3: "hello"};
const Map<int, String> l2 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const {
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE,error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello":
"hello"
};
const Map<int, String> l3 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/const {
3: /*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE,error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
const Map<int, String> l4 = /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER,error:COULD_NOT_INFER*/const {
3:"hello",
/*error:MAP_KEY_TYPE_NOT_ASSIGNABLE,error:MAP_KEY_TYPE_NOT_ASSIGNABLE*/"hello":
/*error:MAP_VALUE_TYPE_NOT_ASSIGNABLE,error:MAP_VALUE_TYPE_NOT_ASSIGNABLE*/3
};
}
}
''');
}
void test_downwardsInferenceYieldYieldStar() {
checkFile('''
import 'dart:async';
abstract class MyStream<T> extends Stream<T> {
factory MyStream() => null;
}
Stream<List<int>> foo() async* {
yield /*info:INFERRED_TYPE_LITERAL*/[];
yield /*error:YIELD_OF_INVALID_TYPE*/new MyStream();
yield* /*error:YIELD_OF_INVALID_TYPE*/[];
yield* /*info:INFERRED_TYPE_ALLOCATION*/new MyStream();
}
Iterable<Map<int, int>> bar() sync* {
yield /*info:INFERRED_TYPE_LITERAL*/{};
yield /*error:YIELD_OF_INVALID_TYPE*/new List();
yield* /*error:YIELD_OF_INVALID_TYPE*/{};
yield* /*info:INFERRED_TYPE_ALLOCATION*/new List();
}
''');
}
test_dynamic_has_object_methods_viaNonPrefixedIdentifier() {
var mainUnit = checkFile('''
dynamic f() => null;
var s = f().toString();
var h = f().hashCode;
''');
var s = mainUnit.topLevelVariables[0];
expect(s.name, 's');
expect(s.type.toString(), 'String');
var h = mainUnit.topLevelVariables[1];
expect(h.name, 'h');
expect(h.type.toString(), 'int');
}
test_dynamic_has_object_methods_viaPrefixedIdentifier() {
var mainUnit = checkFile('''
dynamic d;
var s = d.toString();
var h = d.hashCode;
''');
var s = mainUnit.topLevelVariables[1];
expect(s.name, 's');
expect(s.type.toString(), 'String');
var h = mainUnit.topLevelVariables[2];
expect(h.name, 'h');
expect(h.type.toString(), 'int');
}
void test_fieldRefersToStaticGetter() {
var mainUnit = checkFile('''
class C {
final x = _x;
static int get _x => null;
}
''');
var x = mainUnit.types[0].fields[0];
expect(x.type.toString(), 'int');
}
void test_fieldRefersToTopLevelGetter() {
var mainUnit = checkFile('''
class C {
final x = y;
}
int get y => null;
''');
var x = mainUnit.types[0].fields[0];
expect(x.type.toString(), 'int');
}
void test_futureThen() {
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(T x) {}
dynamic noSuchMethod(invocation);
MyFuture<S> then<S>(FutureOr<S> f(T x), {Function onError}) => null;
}
void main() {
$declared f;
$downwards<int> t1 = f.then((_) async => await new $upwards<int>.value(3));
$downwards<int> t2 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return await new $upwards<int>.value(3);});
$downwards<int> t3 = f.then((_) async => 3);
$downwards<int> t4 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return 3;});
$downwards<int> t5 = f.then((_) => new $upwards<int>.value(3));
$downwards<int> t6 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) {return new $upwards<int>.value(3);});
$downwards<int> t7 = f.then((_) async => new $upwards<int>.value(3));
$downwards<int> t8 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return new $upwards<int>.value(3);});
}
''';
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "Future"));
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "MyFuture", downwards: "MyFuture", upwards: "Future"));
checkFile(build(
declared: "MyFuture", downwards: "MyFuture", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "Future"));
}
void test_futureThen_comment() {
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(T x) {}
dynamic noSuchMethod(invocation);
MyFuture/*<S>*/ then/*<S>*/(dynamic f(T x), {Function onError}) => null;
}
void main() {
$declared f;
$downwards<int> t1 = f.then((_) async => await new $upwards<int>.value(3));
$downwards<int> t2 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return await new $upwards<int>.value(3);});
$downwards<int> t3 = f.then((_) async => 3);
$downwards<int> t4 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return 3;});
$downwards<int> t5 = f.then((_) => new $upwards<int>.value(3));
$downwards<int> t6 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) {return new $upwards<int>.value(3);});
$downwards<int> t7 = f.then((_) async => new $upwards<int>.value(3));
$downwards<int> t8 = f.then(/*info:INFERRED_TYPE_CLOSURE*/(_) async {
return new $upwards<int>.value(3);});
}
''';
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "Future"));
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "MyFuture", downwards: "MyFuture", upwards: "Future"));
checkFile(build(
declared: "MyFuture", downwards: "MyFuture", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "Future"));
}
void test_futureThen_conditional() {
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(T x) {}
dynamic noSuchMethod(invocation);
MyFuture<S> then<S>(FutureOr<S> f(T x), {Function onError}) => null;
}
void main() {
$declared<bool> f;
$downwards<int> t1 = f.then(/*info:INFERRED_TYPE_CLOSURE*/
(x) async => x ? 2 : await new $upwards<int>.value(3));
$downwards<int> t2 = f.then(/*info:INFERRED_TYPE_CLOSURE,info:INFERRED_TYPE_CLOSURE*/(x) async { // TODO(leafp): Why the duplicate here?
return await x ? 2 : new $upwards<int>.value(3);});
$downwards<int> t5 = f.then(/*info:INFERRED_TYPE_CLOSURE,error:INVALID_CAST_FUNCTION_EXPR*/
(x) => x ? 2 : new $upwards<int>.value(3));
$downwards<int> t6 = f.then(/*info:INFERRED_TYPE_CLOSURE*/
(x) {return /*warning:DOWN_CAST_COMPOSITE*/x ? 2 : new $upwards<int>.value(3);});
}
''';
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "Future"));
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "MyFuture", downwards: "MyFuture", upwards: "Future"));
checkFile(build(
declared: "MyFuture", downwards: "MyFuture", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "Future"));
}
void test_futureThen_downwardsMethodTarget() {
// Not working yet, see: https://github.com/dart-lang/sdk/issues/27114
checkFile(r'''
import 'dart:async';
main() {
Future<int> f;
Future<List<int>> b = /*info:ASSIGNMENT_CAST should be pass*/f
.then(/*info:INFERRED_TYPE_CLOSURE*/(x) => [])
.whenComplete(/*pass should be info:INFERRED_TYPE_LITERAL*/() {});
b = f.then(/*info:INFERRED_TYPE_CLOSURE*/(x) => /*info:INFERRED_TYPE_LITERAL*/[]);
}
''');
}
void test_futureThen_explicitFuture() {
checkFile(r'''
import "dart:async";
m1() {
Future<int> f;
var x = f.then<Future<List<int>>>(/*info:INFERRED_TYPE_CLOSURE,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(x) => []);
Future<List<int>> y = x;
}
m2() {
Future<int> f;
var x = f.then<List<int>>(/*info:INFERRED_TYPE_CLOSURE*/(x) => /*info:INFERRED_TYPE_LITERAL*/[]);
Future<List<int>> y = x;
}
''');
}
void test_futureThen_upwards() {
// Regression test for https://github.com/dart-lang/sdk/issues/27088.
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(T x) {}
dynamic noSuchMethod(invocation);
MyFuture<S> then<S>(FutureOr<S> f(T x), {Function onError}) => null;
}
void main() {
var f = foo().then((_) => 2.3);
$downwards<int> f2 = /*error:INVALID_ASSIGNMENT*/f;
// The unnecessary cast is to illustrate that we inferred <double> for
// the generic type args, even though we had a return type context.
$downwards<num> f3 = /*info:UNNECESSARY_CAST*/foo().then(
(_) => 2.3) as $upwards<double>;
}
$declared foo() => new $declared<int>.value(1);
''';
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "Future"));
checkFile(build(
declared: "MyFuture", downwards: "MyFuture", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "Future"));
}
void test_futureThen_upwardsFromBlock() {
// Regression test for https://github.com/dart-lang/sdk/issues/27113.
checkFile(r'''
import 'dart:async';
main() {
Future<int> base;
var f = base.then(/*info:INFERRED_TYPE_CLOSURE,info:INFERRED_TYPE_CLOSURE*/(x) { return x == 0; });
var g = base.then(/*info:INFERRED_TYPE_CLOSURE*/(x) => x == 0);
Future<bool> b = f;
b = g;
}
''');
}
void test_futureOr_subtyping() {
checkFile(r'''
import 'dart:async';
void add(int x) {}
add2(int y) {}
main() {
Future<int> f;
var a = f.then(add);
var b = f.then(add2);
}
''');
}
void test_futureUnion_asyncConditional() {
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(x) {}
dynamic noSuchMethod(invocation);
MyFuture<S> then<S>(FutureOr<S> f(T x), {Function onError}) => null;
}
$downwards<int> g1(bool x) async {
return x ? 42 : /*info:INFERRED_TYPE_ALLOCATION*/new $upwards.value(42); }
$downwards<int> g2(bool x) async =>
x ? 42 : /*info:INFERRED_TYPE_ALLOCATION*/new $upwards.value(42);
$downwards<int> g3(bool x) async {
var y = x ? 42 : new $upwards.value(42);
return y;
}
''';
checkFile(build(downwards: "Future", upwards: "Future"));
checkFile(build(downwards: "Future", upwards: "MyFuture"));
}
void test_futureUnion_asyncConditional_comment() {
String build({String declared, String downwards, String upwards}) => '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value(x) {}
dynamic noSuchMethod(invocation);
MyFuture/*<S>*/ then/*<S>*/(dynamic f(T x), {Function onError}) => null;
}
$downwards<int> g1(bool x) async {
return x ? 42 : /*info:INFERRED_TYPE_ALLOCATION*/new $upwards.value(42); }
$downwards<int> g2(bool x) async =>
x ? 42 : /*info:INFERRED_TYPE_ALLOCATION*/new $upwards.value(42);
$downwards<int> g3(bool x) async {
var y = x ? 42 : new $upwards.value(42);
return y;
}
''';
checkFile(build(downwards: "Future", upwards: "Future"));
checkFile(build(downwards: "Future", upwards: "MyFuture"));
}
void test_futureUnion_downwards() {
String build({String declared, String downwards, String upwards}) {
// TODO(leafp): The use of matchTypes in visitInstanceCreationExpression
// in the resolver visitor isn't powerful enough to catch this for the
// subclass. See the TODO there.
var allocInfo =
(upwards == "Future") ? "/*info:INFERRED_TYPE_ALLOCATION*/" : "";
return '''
import 'dart:async';
class MyFuture<T> implements Future<T> {
MyFuture() {}
MyFuture.value([x]) {}
dynamic noSuchMethod(invocation);
MyFuture<S> then<S>(FutureOr<S> f(T x), {Function onError}) => null;
}
$declared f;
// Instantiates Future<int>
$downwards<int> t1 = f.then((_) =>
${allocInfo}new $upwards.value('hi'));
// Instantiates List<int>
$downwards<List<int>> t2 = f.then((_) => /*info:INFERRED_TYPE_LITERAL*/[3]);
$downwards<List<int>> g2() async { return /*info:INFERRED_TYPE_LITERAL*/[3]; }
$downwards<List<int>> g3() async {
return /*info:INFERRED_TYPE_ALLOCATION*/new $upwards.value(
/*info:INFERRED_TYPE_LITERAL*/[3]); }
''';
}
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "Future"));
checkFile(
build(declared: "MyFuture", downwards: "Future", upwards: "MyFuture"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "Future"));
checkFile(
build(declared: "Future", downwards: "Future", upwards: "MyFuture"));
}
void test_futureUnion_downwardsGenericMethodWithFutureReturn() {
// Regression test for https://github.com/dart-lang/sdk/issues/27134
//
// We need to take a future union into account for both directions of
// generic method inference.
checkFile(r'''
import 'dart:async';
foo() async {
Future<List<A>> f1 = null;
Future<List<A>> f2 = null;
List<List<A>> merged = await Future.wait(/*info:INFERRED_TYPE_LITERAL*/[f1, f2]);
}
class A {}
''');
}
void test_futureUnion_downwardsGenericMethodWithGenericReturn() {
// Regression test for https://github.com/dart-lang/sdk/issues/27284
checkFile(r'''
import 'dart:async';
T id<T>(T x) => x;
main() async {
Future<String> f;
String s = await id(f);
}
''');
}
void test_futureUnion_downwardsGenericMethodWithGenericReturn_comment() {
// Regression test for https://github.com/dart-lang/sdk/issues/27284
checkFile(r'''
import 'dart:async';
/*=T*/ id/*<T>*/(/*=T*/ x) => x;
main() async {
Future<String> f;
String s = await id(f);
}
''');
}
void test_futureUnion_upwardsGenericMethods() {
// Regression test for https://github.com/dart-lang/sdk/issues/27151
checkFile(r'''
import 'dart:async';
main() async {
var b = new Future<B>.value(new B());
var c = new Future<C>.value(new C());
var lll = /*info:INFERRED_TYPE_LITERAL*/[b, c];
var result = await Future.wait(lll);
var result2 = await Future.wait(/*info:INFERRED_TYPE_LITERAL*/[b, c]);
List<A> list = result;
list = result2;
}
class A {}
class B extends A {}
class C extends A {}
''');
}
void test_genericFunctions_returnTypedef() {
checkFile(r'''
typedef void ToValue<T>(T value);
main() {
ToValue<T> f<T>(T x) => null;
var x = f<int>(42);
var y = f(42);
ToValue<int> takesInt = x;
takesInt = y;
}
''');
}
void test_genericFunctions_returnTypedef_comment() {
checkFile(r'''
typedef void ToValue<T>(T value);
main() {
ToValue/*<T>*/ f/*<T>*/(dynamic /*=T*/ x) => null;
var x = f/*<int>*/(42);
var y = f(42);
ToValue<int> takesInt = x;
takesInt = y;
}
''');
}
void test_genericMethods_basicDownwardInference() {
checkFile(r'''
T f<S, T>(S s) => null;
main() {
String x = f(42);
String y = (f)(42);
}
''');
}
void test_genericMethods_basicDownwardInference_comment() {
checkFile(r'''
/*=T*/ f/*<S, T>*/(/*=S*/ s) => null;
main() {
String x = f(42);
String y = (f)(42);
}
''');
}
void test_genericMethods_correctlyRecognizeGenericUpperBound() {
// Regression test for https://github.com/dart-lang/sdk/issues/25740.
checkFile(r'''
class Foo<T extends Pattern> {
U method<U extends T>(U u) => u;
}
main() {
String s;
var a = new Foo().method<String>("str");
s = a;
new Foo();
var b = new Foo<String>().method("str");
s = b;
var c = new Foo().method("str");
s = c;
new Foo<String>()./*error:COULD_NOT_INFER*/method(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/42);
}
''');
}
void test_genericMethods_correctlyRecognizeGenericUpperBound_comment() {
// Regression test for https://github.com/dart-lang/sdk/issues/25740.
checkFile(r'''
class Foo<T extends Pattern> {
/*=U*/ method/*<U extends T>*/(/*=U*/ u) => u;
}
main() {
String s;
var a = new Foo().method/*<String>*/("str");
s = a;
new Foo();
var b = new Foo<String>().method("str");
s = b;
var c = new Foo().method("str");
s = c;
new Foo<String>()./*error:COULD_NOT_INFER*/method(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/42);
}
''');
}
void test_genericMethods_dartMathMinMax() {
checkFile('''
import 'dart:math';
void printInt(int x) => print(x);
void printDouble(double x) => print(x);
num myMax(num x, num y) => max(x, y);
main() {
// Okay if static types match.
printInt(max(1, 2));
printInt(min(1, 2));
printDouble(max(1.0, 2.0));
printDouble(min(1.0, 2.0));
// No help for user-defined functions from num->num->num.
printInt(/*info:DOWN_CAST_IMPLICIT*/myMax(1, 2));
printInt(myMax(1, 2) as int);
// Mixing int and double means return type is num.
printInt(/*error:COULD_NOT_INFER*/max(1, /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/2.0));
printInt(/*error:COULD_NOT_INFER*/min(1, /*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/2.0));
printDouble(/*error:COULD_NOT_INFER*/max(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/1, 2.0));
printDouble(/*error:COULD_NOT_INFER*/min(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/1, 2.0));
// Types other than int and double are not accepted.
printInt(
/*error:COULD_NOT_INFER*/min(
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"hi",
/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/"there"));
}
''');
}
void test_genericMethods_doNotInferInvalidOverrideOfGenericMethod() {
checkFile('''
class C {
T m<T>(T x) => x;
}
class D extends C {
/*error:INVALID_METHOD_OVERRIDE*/m(x) => x;
}
main() {
int y = /*info:DYNAMIC_CAST*/new D()./*error:WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD*/m<int>(42);
print(y);
}
''');
}
void test_genericMethods_doNotInferInvalidOverrideOfGenericMethod_comment() {
checkFile('''
class C {
/*=T*/ m/*<T>*/(/*=T*/ x) => x;
}
class D extends C {
/*error:INVALID_METHOD_OVERRIDE*/m(x) => x;
}
main() {
int y = /*info:DYNAMIC_CAST*/new D()./*error:WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD*/m/*<int>*/(42);
print(y);
}
''');
}
void test_genericMethods_downwardsInferenceAffectsArguments() {
checkFile(r'''
T f<T>(List<T> s) => null;
main() {
String x = f(/*info:INFERRED_TYPE_LITERAL*/['hi']);
String y = f(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/42]);
}
''');
}
void test_genericMethods_downwardsInferenceAffectsArguments_comment() {
checkFile(r'''
/*=T*/ f/*<T>*/(List/*<T>*/ s) => null;
main() {
String x = f(/*info:INFERRED_TYPE_LITERAL*/['hi']);
String y = f(/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*error:LIST_ELEMENT_TYPE_NOT_ASSIGNABLE*/42]);
}
''');
}
void test_genericMethods_downwardsInferenceFold() {
// Regression from https://github.com/dart-lang/sdk/issues/25491
// The first example works now, but the latter requires a full solution to
// https://github.com/dart-lang/sdk/issues/25490
checkFile(r'''
void main() {
List<int> o;
int y = o.fold(0, /*info:INFERRED_TYPE_CLOSURE*/(x, y) => x + y);
var z = o.fold(0, /*info:INFERRED_TYPE_CLOSURE*/(x, y) => /*info:DYNAMIC_INVOKE*/x + y);
y = /*info:DYNAMIC_CAST*/z;
}
void functionExpressionInvocation() {
List<int> o;
int y = (o.fold)(0, /*info:INFERRED_TYPE_CLOSURE*/(x, y) => x + y);
var z = (o.fold)(0, /*info:INFERRED_TYPE_CLOSURE*/(x, y) => /*info:DYNAMIC_INVOKE*/x + y);
y = /*info:DYNAMIC_CAST*/z;
}
''');
}
void test_genericMethods_handleOverrideOfNonGenericWithGeneric() {
// Regression test for crash when adding genericity
checkFile('''
class C {
m(x) => x;
dynamic g(int x) => x;
}
class D extends C {
/*error:INVALID_METHOD_OVERRIDE*/T m<T>(T x) => x;
/*error:INVALID_METHOD_OVERRIDE*/T g<T>(T x) => x;
}
main() {
int y = /*info:DYNAMIC_CAST*/(/*info:UNNECESSARY_CAST*/new D() as C).m(42);
print(y);
}
''');
}
void test_genericMethods_inferenceError() {
checkFile(r'''
main() {
List<String> y;
Iterable<String> x = y./*error:COULD_NOT_INFER*/map(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(String z) => 1.0);
}
''');
}
void test_genericMethods_inferGenericFunctionParameterType() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f<U>(x) {}
}
class D<T> {
F<U> f<U>(U u) => null;
}
typedef void F<V>(V v);
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(U) → (U) → void');
}
void test_genericMethods_inferGenericFunctionParameterType2() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f<U>(g) => null;
}
abstract class D<T> {
void f<U>(G<U> g);
}
typedef List<V> G<V>();
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(() → List<U>) → void');
}
void test_genericMethods_inferGenericFunctionParameterType2_comment() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f/*<U>*/(g) => null;
}
abstract class D<T> {
void f/*<U>*/(G/*<U>*/ g);
}
typedef List<V> G<V>();
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(() → List<U>) → void');
}
void test_genericMethods_inferGenericFunctionParameterType_comment() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f/*<U>*/(x) {}
}
class D<T> {
F/*<U>*/ f/*<U>*/(/*=U*/ u) => null;
}
typedef void F<V>(V v);
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(U) → (U) → void');
}
void test_genericMethods_inferGenericFunctionReturnType() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f<U>(x) {}
}
class D<T> {
F<U> f<U>(U u) => null;
}
typedef V F<V>();
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(U) → () → U');
}
void test_genericMethods_inferGenericFunctionReturnType_comment() {
var mainUnit = checkFile('''
class C<T> extends D<T> {
f/*<U>*/(x) {}
}
class D<T> {
F/*<U>*/ f/*<U>*/(/*=U*/ u) => null;
}
typedef V F<V>();
''');
var f = mainUnit.getType('C').methods[0];
expect(f.type.toString(), '<U>(U) → () → U');
}
void test_genericMethods_inferGenericInstantiation() {
checkFile('''
import 'dart:math' as math;
import 'dart:math' show min;
class C {
T m<T extends num>(T x, T y) => null;
}
main() {
takeIII(math.max);
takeDDD(math.max);
takeNNN(math.max);
takeIDN(math.max);
takeDIN(math.max);
takeIIN(math.max);
takeDDN(math.max);
takeIIO(math.max);
takeDDO(math.max);
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
// Also test SimpleIdentifier
takeIII(min);
takeDDD(min);
takeNNN(min);
takeIDN(min);
takeDIN(min);
takeIIN(min);
takeDDN(min);
takeIIO(min);
takeDDO(min);
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
// Also PropertyAccess
takeIII(new C().m);
takeDDD(new C().m);
takeNNN(new C().m);
takeIDN(new C().m);
takeDIN(new C().m);
takeIIN(new C().m);
takeDDN(new C().m);
takeIIO(new C().m);
takeDDO(new C().m);
// Note: this is a warning because a downcast of a method tear-off could work
// (derived method can be a subtype):
//
// class D extends C {
// S m<S extends num>(Object x, Object y);
// }
//
// That's legal because we're loosening parameter types.
//
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
// Note: this is a warning because a downcast of a method tear-off could work
// in "normal" Dart, due to bivariance.
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
}
void takeIII(int fn(int a, int b)) {}
void takeDDD(double fn(double a, double b)) {}
void takeIDI(int fn(double a, int b)) {}
void takeDID(double fn(int a, double b)) {}
void takeIDN(num fn(double a, int b)) {}
void takeDIN(num fn(int a, double b)) {}
void takeIIN(num fn(int a, int b)) {}
void takeDDN(num fn(double a, double b)) {}
void takeNNN(num fn(num a, num b)) {}
void takeOON(num fn(Object a, Object b)) {}
void takeOOO(num fn(Object a, Object b)) {}
void takeOOI(int fn(Object a, Object b)) {}
void takeIIO(Object fn(int a, int b)) {}
void takeDDO(Object fn(double a, double b)) {}
''');
}
void test_genericMethods_inferGenericInstantiation_comment() {
checkFile('''
import 'dart:math' as math;
import 'dart:math' show min;
class C {
/*=T*/ m/*<T extends num>*/(/*=T*/ x, /*=T*/ y) => null;
}
main() {
takeIII(math.max);
takeDDD(math.max);
takeNNN(math.max);
takeIDN(math.max);
takeDIN(math.max);
takeIIN(math.max);
takeDDN(math.max);
takeIIO(math.max);
takeDDO(math.max);
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/math.max);
// Also test SimpleIdentifier
takeIII(min);
takeDDD(min);
takeNNN(min);
takeIDN(min);
takeDIN(min);
takeIIN(min);
takeDDN(min);
takeIIO(min);
takeDDO(min);
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/min);
// Also PropertyAccess
takeIII(new C().m);
takeDDD(new C().m);
takeNNN(new C().m);
takeIDN(new C().m);
takeDIN(new C().m);
takeIIN(new C().m);
takeDDN(new C().m);
takeIIO(new C().m);
takeDDO(new C().m);
// Note: this is a warning because a downcast of a method tear-off could work
// (derived method can be a subtype):
//
// class D extends C {
// S m<S extends num>(Object x, Object y);
// }
//
// That's legal because we're loosening parameter types.
//
takeOON(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeOOO(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
// Note: this is a warning because a downcast of a method tear-off could work
// in "normal" Dart, due to bivariance.
takeOOI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeIDI(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
takeDID(/*error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/new C().m);
}
void takeIII(int fn(int a, int b)) {}
void takeDDD(double fn(double a, double b)) {}
void takeIDI(int fn(double a, int b)) {}
void takeDID(double fn(int a, double b)) {}
void takeIDN(num fn(double a, int b)) {}
void takeDIN(num fn(int a, double b)) {}
void takeIIN(num fn(int a, int b)) {}
void takeDDN(num fn(double a, double b)) {}
void takeNNN(num fn(num a, num b)) {}
void takeOON(num fn(Object a, Object b)) {}
void takeOOO(num fn(Object a, Object b)) {}
void takeOOI(int fn(Object a, Object b)) {}
void takeIIO(Object fn(int a, int b)) {}
void takeDDO(Object fn(double a, double b)) {}
''');
}
void test_genericMethods_inferGenericMethodType() {
// Regression test for https://github.com/dart-lang/sdk/issues/25668
checkFile('''
class C {
T m<T>(T x) => x;
}
class D extends C {
m<S>(x) => x;
}
main() {
int y = new D().m<int>(42);
print(y);
}
''');
}
void test_genericMethods_inferGenericMethodType_comment() {
// Regression test for https://github.com/dart-lang/sdk/issues/25668
checkFile('''
class C {
/*=T*/ m/*<T>*/(/*=T*/ x) => x;
}
class D extends C {
m/*<S>*/(x) => x;
}
main() {
int y = new D().m/*<int>*/(42);
print(y);
}
''');
}
void test_genericMethods_inferJSBuiltin() {
// TODO(jmesserly): we should change how this inference works.
// For now this test will cover what we use.
checkFile('''
/*error:IMPORT_INTERNAL_LIBRARY*/import 'dart:_foreign_helper' show JS;
main() {
String x = /*error:INVALID_ASSIGNMENT*/JS('int', '42');
var y = JS('String', '"hello"');
y = "world";
y = /*error:INVALID_ASSIGNMENT*/42;
}
''');
}
void test_genericMethods_IterableAndFuture() {
checkFile('''
import 'dart:async';
Future<int> make(int x) => (/*info:INFERRED_TYPE_ALLOCATION*/new Future(() => x));
main() {
Iterable<Future<int>> list = <int>[1, 2, 3].map(make);
Future<List<int>> results = Future.wait(list);
Future<String> results2 = results.then((List<int> list)
=> list.fold('', /*info:INFERRED_TYPE_CLOSURE*/(x, y) => /*info:DYNAMIC_CAST,info:DYNAMIC_INVOKE*/x /*error:UNDEFINED_OPERATOR*/+ y.toString()));
Future<String> results3 = results.then((List<int> list)
=> list.fold('', /*info:INFERRED_TYPE_CLOSURE*/(String x, y) => x + y.toString()));
}
''');
}
void test_genericMethods_usesGreatestLowerBound() {
var mainUnit = checkFile(r'''
typedef Iterable<num> F(int x);
typedef List<int> G(double x);
T generic<T>(a(T _), b(T _)) => null;
var v = generic((F f) => null, (G g) => null);
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), '(num) → List<int>');
}
void test_genericMethods_usesGreatestLowerBound_comment() {
var mainUnit = checkFile(r'''
typedef Iterable<num> F(int x);
typedef List<int> G(double x);
/*=T*/ generic/*<T>*/(a(/*=T*/ _), b(/*=T*/ _)) => null;
var v = generic((F f) => null, (G g) => null);
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), '(num) → List<int>');
}
void test_infer_assignToIndex() {
checkFile(r'''
List<double> a = <double>[];
var b = (a[0] = 1.0);
''');
}
void test_infer_assignToProperty() {
checkFile(r'''
class A {
int f;
}
var v_assign = (new A().f = 1);
var v_plus = (new A().f += 1);
var v_minus = (new A().f -= 1);
var v_multiply = (new A().f *= 1);
var v_prefix_pp = (++new A().f);
var v_prefix_mm = (--new A().f);
var v_postfix_pp = (new A().f++);
var v_postfix_mm = (new A().f--);
''');
}
void test_infer_assignToProperty_custom() {
checkFile(r'''
class A {
int operator +(other) => 1;
double operator -(other) => 2.0;
}
class B {
A a;
}
var v_prefix_pp = (++new B().a);
var v_prefix_mm = (--new B().a);
var v_postfix_pp = (new B().a++);
var v_postfix_mm = (new B().a--);
''');
}
void test_infer_assignToRef() {
checkFile(r'''
class A {
int f;
}
A a = new A();
var b = (a.f = 1);
var c = 0;
var d = (c = 1);
''');
}
void test_infer_binary_custom() {
checkFile(r'''
class A {
int operator +(other) => 1;
double operator -(other) => 2.0;
}
var v_add = new A() + 'foo';
var v_minus = new A() - 'bar';
''');
}
void test_infer_binary_doubleDouble() {
checkFile(r'''
var a_equal = 1.0 == 2.0;
var a_notEqual = 1.0 != 2.0;
var a_add = 1.0 + 2.0;
var a_subtract = 1.0 - 2.0;
var a_multiply = 1.0 * 2.0;
var a_divide = 1.0 / 2.0;
var a_floorDivide = 1.0 ~/ 2.0;
var a_greater = 1.0 > 2.0;
var a_less = 1.0 < 2.0;
var a_greaterEqual = 1.0 >= 2.0;
var a_lessEqual = 1.0 <= 2.0;
var a_modulo = 1.0 % 2.0;
''');
}
void test_infer_binary_doubleInt() {
checkFile(r'''
var a_equal = 1.0 == 2;
var a_notEqual = 1.0 != 2;
var a_add = 1.0 + 2;
var a_subtract = 1.0 - 2;
var a_multiply = 1.0 * 2;
var a_divide = 1.0 / 2;
var a_floorDivide = 1.0 ~/ 2;
var a_greater = 1.0 > 2;
var a_less = 1.0 < 2;
var a_greaterEqual = 1.0 >= 2;
var a_lessEqual = 1.0 <= 2;
var a_modulo = 1.0 % 2;
''');
}
void test_infer_binary_intDouble() {
checkFile(r'''
var a_equal = 1 == 2.0;
var a_notEqual = 1 != 2.0;
var a_add = 1 + 2.0;
var a_subtract = 1 - 2.0;
var a_multiply = 1 * 2.0;
var a_divide = 1 / 2.0;
var a_floorDivide = 1 ~/ 2.0;
var a_greater = 1 > 2.0;
var a_less = 1 < 2.0;
var a_greaterEqual = 1 >= 2.0;
var a_lessEqual = 1 <= 2.0;
var a_modulo = 1 % 2.0;
''');
}
void test_infer_binary_intInt() {
checkFile(r'''
var a_equal = 1 == 2;
var a_notEqual = 1 != 2;
var a_bitXor = 1 ^ 2;
var a_bitAnd = 1 & 2;
var a_bitOr = 1 | 2;
var a_bitShiftRight = 1 >> 2;
var a_bitShiftLeft = 1 << 2;
var a_add = 1 + 2;
var a_subtract = 1 - 2;
var a_multiply = 1 * 2;
var a_divide = 1 / 2;
var a_floorDivide = 1 ~/ 2;
var a_greater = 1 > 2;
var a_less = 1 < 2;
var a_greaterEqual = 1 >= 2;
var a_lessEqual = 1 <= 2;
var a_modulo = 1 % 2;
''');
}
void test_infer_conditional() {
checkFile(r'''
var a = 1 == 2 ? 1 : 2.0;
var b = 1 == 2 ? 1.0 : 2;
''');
}
void test_infer_prefixExpression() {
checkFile(r'''
var a_not = !true;
var a_complement = ~1;
var a_negate = -1;
''');
}
void test_infer_prefixExpression_custom() {
checkFile(r'''
class A {
A();
int operator ~() => 1;
double operator -() => 2.0;
}
var a = new A();
var v_complement = ~a;
var v_negate = -a;
''');
}
void test_infer_throw() {
checkFile(r'''
var t = true;
var a = (throw 0);
var b = (throw 0) ? 1 : 2;
var c = t ? (throw 1) : 2;
var d = t ? 1 : (throw 2);
''');
}
void test_infer_typeCast() {
checkFile(r'''
class A<T> {}
class B<T> extends A<T> {
foo() {}
}
A<num> a = new B<int>();
var b = (a as B<int>);
main() {
b.foo();
}
''');
}
void test_infer_typedListLiteral() {
checkFile(r'''
var a = <int>[];
var b = <double>[1.0, 2.0, 3.0];
var c = <List<int>>[];
var d = <dynamic>[1, 2.0, false];
''');
}
void test_infer_typedMapLiteral() {
checkFile(r'''
var a = <int, String>{0: 'aaa', 1: 'bbb'};
var b = <double, int>{1.1: 1, 2.2: 2};
var c = <List<int>, Map<String, double>>{};
var d = <int, dynamic>{};
var e = <dynamic, int>{};
var f = <dynamic, dynamic>{};
''');
}
void test_infer_use_of_void() {
checkFile('''
class B {
void f() {}
}
class C extends B {
f() {}
}
var x = new C()./*info:USE_OF_VOID_RESULT*/f();
''');
}
void test_inferConstsTransitively() {
addFile(
'''
const b1 = 2;
''',
name: '/b.dart');
addFile(
'''
import 'main.dart';
import 'b.dart';
const a1 = m2;
const a2 = b1;
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
const m1 = a1;
const m2 = a2;
foo() {
int i;
i = m1;
}
''');
}
void test_inferCorrectlyOnMultipleVariablesDeclaredTogether() {
checkFile('''
class A {
var x, y = 2, z = "hi";
}
class B implements A {
var x = 2, y = 3, z, w = 2;
}
foo() {
String s;
int i;
s = /*info:DYNAMIC_CAST*/new B().x;
s = /*error:INVALID_ASSIGNMENT*/new B().y;
s = new B().z;
s = /*error:INVALID_ASSIGNMENT*/new B().w;
i = /*info:DYNAMIC_CAST*/new B().x;
i = new B().y;
i = /*error:INVALID_ASSIGNMENT*/new B().z;
i = new B().w;
}
''');
}
void test_inferedType_usesSyntheticFunctionType() {
var mainUnit = checkFile('''
int f() => null;
String g() => null;
var v = /*info:INFERRED_TYPE_LITERAL*/[f, g];
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'List<() → Object>');
}
void test_inferedType_usesSyntheticFunctionType_functionTypedParam() {
var mainUnit = checkFile('''
int f(int x(String y)) => null;
String g(int x(String y)) => null;
var v = /*info:INFERRED_TYPE_LITERAL*/[f, g];
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'List<((String) → int) → Object>');
}
void test_inferedType_usesSyntheticFunctionType_namedParam() {
var mainUnit = checkFile('''
int f({int x}) => null;
String g({int x}) => null;
var v = /*info:INFERRED_TYPE_LITERAL*/[f, g];
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'List<({x: int}) → Object>');
}
void test_inferedType_usesSyntheticFunctionType_positionalParam() {
var mainUnit = checkFile('''
int f([int x]) => null;
String g([int x]) => null;
var v = /*info:INFERRED_TYPE_LITERAL*/[f, g];
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'List<([int]) → Object>');
}
void test_inferedType_usesSyntheticFunctionType_requiredParam() {
var mainUnit = checkFile('''
int f(int x) => null;
String g(int x) => null;
var v = /*info:INFERRED_TYPE_LITERAL*/[f, g];
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'List<(int) → Object>');
}
void test_inferenceInCyclesIsDeterministic() {
addFile(
'''
import 'b.dart';
class A {
static final a1 = B.b1;
final a2 = new B().b2;
}
''',
name: '/a.dart');
addFile(
'''
class B {
static final b1 = 1;
final b2 = 1;
}
''',
name: '/b.dart');
addFile(
'''
import "main.dart"; // creates a cycle
class C {
static final c1 = 1;
final c2 = 1;
}
''',
name: '/c.dart');
addFile(
'''
library e;
import 'a.dart';
part 'e2.dart';
class E {
static final e1 = 1;
static final e2 = F.f1;
static final e3 = A.a1;
final e4 = 1;
final e5 = new F().f2;
final e6 = new A().a2;
}
''',
name: '/e.dart');
addFile(
'''
part 'f2.dart';
''',
name: '/f.dart');
addFile(
'''
part of e;
class F {
static final f1 = 1;
final f2 = 1;
}
''',
name: '/e2.dart');
checkFile('''
import "a.dart";
import "c.dart";
import "e.dart";
class D {
static final d1 = A.a1 + 1;
static final d2 = C.c1 + 1;
final d3 = new A().a2;
final d4 = new C().c2;
}
test1() {
int x = 0;
// inference in A works, it's not in a cycle
x = A.a1;
x = new A().a2;
// Within a cycle we allow inference when the RHS is well known, but
// not when it depends on other fields within the cycle
x = C.c1;
x = D.d1;
x = D.d2;
x = new C().c2;
x = new D().d3;
x = /*info:DYNAMIC_CAST*/new D().d4;
// Similarly if the library contains parts.
x = E.e1;
x = E.e2;
x = E.e3;
x = new E().e4;
x = /*info:DYNAMIC_CAST*/new E().e5;
x = new E().e6;
x = F.f1;
x = new F().f2;
}
''');
}
void test_inferFromComplexExpressionsIfOuterMostValueIsPrecise() {
checkFile('''
class A { int x; B operator+(other) => null; }
class B extends A { B(ignore); }
var a = new A();
// Note: it doesn't matter that some of these refer to 'x'.
var b = new B(/*error:UNDEFINED_IDENTIFIER*/x); // allocations
var c1 = [/*error:UNDEFINED_IDENTIFIER*/x]; // list literals
var c2 = const [];
var d = <dynamic, dynamic>{'a': 'b'}; // map literals
var e = new A()..x = 3; // cascades
var f = 2 + 3; // binary expressions are OK if the left operand
// is from a library in a different strongest
// conected component.
var g = -3;
var h = new A() + 3;
var i = /*error:UNDEFINED_OPERATOR,info:DYNAMIC_INVOKE*/- new A();
var j = /*info:UNNECESSARY_CAST*/null as B;
test1() {
a = /*error:INVALID_ASSIGNMENT*/"hi";
a = new B(3);
b = /*error:INVALID_ASSIGNMENT*/"hi";
b = new B(3);
c1 = [];
c1 = /*error:INVALID_ASSIGNMENT*/{};
c2 = [];
c2 = /*error:INVALID_ASSIGNMENT*/{};
d = {};
d = /*error:INVALID_ASSIGNMENT*/3;
e = new A();
e = /*error:INVALID_ASSIGNMENT*/{};
f = 3;
f = /*error:INVALID_ASSIGNMENT*/false;
g = 1;
g = /*error:INVALID_ASSIGNMENT*/false;
h = /*error:INVALID_ASSIGNMENT*/false;
h = new B('b');
i = false;
j = new B('b');
j = /*error:INVALID_ASSIGNMENT*/false;
j = /*error:INVALID_ASSIGNMENT*/[];
}
''');
}
void test_inferFromRhsOnlyIfItWontConflictWithOverriddenFields() {
checkFile('''
class A {
var x;
}
class B implements A {
var x = 2;
}
foo() {
String y = /*info:DYNAMIC_CAST*/new B().x;
int z = /*info:DYNAMIC_CAST*/new B().x;
}
''');
}
void test_inferFromRhsOnlyIfItWontConflictWithOverriddenFields2() {
checkFile('''
class A {
final x = null;
}
class B implements A {
final x = 2;
}
foo() {
String y = /*error:INVALID_ASSIGNMENT*/new B().x;
int z = new B().x;
}
''');
}
void test_inferFromVariablesInCycleLibsWhenFlagIsOn() {
addFile(
'''
import 'main.dart';
var x = 2; // ok to infer
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
var y = x; // now ok :)
test1() {
int t = 3;
t = x;
t = y;
}
''');
}
void test_inferFromVariablesInCycleLibsWhenFlagIsOn2() {
addFile(
'''
import 'main.dart';
class A { static var x = 2; }
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
class B { static var y = A.x; }
test1() {
int t = 3;
t = A.x;
t = B.y;
}
''');
}
void test_inferFromVariablesInNonCycleImportsWithFlag() {
addFile(
'''
var x = 2;
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
var y = x;
test1() {
x = /*error:INVALID_ASSIGNMENT*/"hi";
y = /*error:INVALID_ASSIGNMENT*/"hi";
}
''');
}
void test_inferFromVariablesInNonCycleImportsWithFlag2() {
addFile(
'''
class A { static var x = 2; }
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
class B { static var y = A.x; }
test1() {
A.x = /*error:INVALID_ASSIGNMENT*/"hi";
B.y = /*error:INVALID_ASSIGNMENT*/"hi";
}
''');
}
void test_inferGenericMethodType_named() {
var unit = checkFile('''
class C {
T m<T>(int a, {String b, T c}) => null;
}
var y = new C().m(1, b: 'bbb', c: 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_named_comment() {
var unit = checkFile('''
class C {
/*=T*/ m/*<T>*/(int a, {String b, /*=T*/ c}) => null;
}
var y = new C().m(1, b: 'bbb', c: 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_positional() {
var unit = checkFile('''
class C {
T m<T>(int a, [T b]) => null;
}
var y = new C().m(1, 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_positional2() {
var unit = checkFile('''
class C {
T m<T>(int a, [String b, T c]) => null;
}
var y = new C().m(1, 'bbb', 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_positional2_comment() {
var unit = checkFile('''
class C {
/*=T*/ m/*<T>*/(int a, [String b, /*=T*/ c]) => null;
}
var y = new C().m(1, 'bbb', 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_positional_comment() {
var unit = checkFile('''
class C {
/*=T*/ m/*<T>*/(int a, [/*=T*/ b]) => null;
}
var y = new C().m(1, 2.0);
''');
expect(unit.topLevelVariables[0].type.toString(), 'double');
}
void test_inferGenericMethodType_required() {
var unit = checkFile('''
class C {
T m<T>(T x) => x;
}
var y = new C().m(42);
''');
expect(unit.topLevelVariables[0].type.toString(), 'int');
}
void test_inferGenericMethodType_required_comment() {
var unit = checkFile('''
class C {
/*=T*/ m/*<T>*/(/*=T*/ x) => x;
}
var y = new C().m(42);
''');
expect(unit.topLevelVariables[0].type.toString(), 'int');
}
void test_inferIfComplexExpressionsReadPossibleInferredField() {
// but flags can enable this behavior.
addFile(
'''
class A {
var x = 3;
}
''',
name: '/a.dart');
checkFile('''
import 'a.dart';
class B {
var y = 3;
}
final t1 = new A();
final t2 = new A().x;
final t3 = new B();
final t4 = new B().y;
test1() {
int i = 0;
A a;
B b;
a = t1;
i = t2;
b = t3;
i = /*info:DYNAMIC_CAST*/t4;
i = new B().y; // B.y was inferred though
}
''');
}
void test_inferListLiteralNestedInMapLiteral() {
checkFile(r'''
class Resource {}
class Folder extends Resource {}
Resource getResource(String str) => null;
class Foo<T> {
Foo(T t);
}
main() {
// List inside map
var map = <String, List<Folder>>{
'pkgA': /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*info:DOWN_CAST_IMPLICIT*/getResource('/pkgA/lib/')],
'pkgB': /*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*info:DOWN_CAST_IMPLICIT*/getResource('/pkgB/lib/')]
};
// Also try map inside list
var list = <Map<String, Folder>>[
/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{ 'pkgA': /*info:DOWN_CAST_IMPLICIT*/getResource('/pkgA/lib/') },
/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/{ 'pkgB': /*info:DOWN_CAST_IMPLICIT*/getResource('/pkgB/lib/') },
];
// Instance creation too
var foo = new Foo<List<Folder>>(
/*info:INFERRED_TYPE_LITERAL,error:COULD_NOT_INFER*/[/*info:DOWN_CAST_IMPLICIT*/getResource('/pkgA/lib/')]
);
}
''');
}
void test_inferLocalFunctionReturnType() {
// Regression test for https://github.com/dart-lang/sdk/issues/26414
var unit = checkFile(r'''
main() {
f0() => 42;
f1() async => 42;
f2 /*info:INFERRED_TYPE_CLOSURE*/() { return 42; }
f3 /*info:INFERRED_TYPE_CLOSURE*/() async { return 42; }
f4 /*info:INFERRED_TYPE_CLOSURE*/() sync* { yield 42; }
f5 /*info:INFERRED_TYPE_CLOSURE*/() async* { yield 42; }
num f6() => 42;
f7() => f7();
f8() => /*error:REFERENCED_BEFORE_DECLARATION*/f9();
f9() => f5();
}
''');
var fns = unit.functions[0].functions;
expect(fns[0].type.toString(), '() → int');
expect(fns[1].type.toString(), '() → Future<int>');
expect(fns[2].type.toString(), '() → int');
expect(fns[3].type.toString(), '() → Future<int>');
expect(fns[4].type.toString(), '() → Iterable<int>');
expect(fns[5].type.toString(), '() → Stream<int>');
expect(fns[6].type.toString(), '() → num');
// Recursive cases: these infer in declaration order.
expect(fns[7].type.toString(), '() → dynamic');
expect(fns[8].type.toString(), '() → dynamic');
expect(fns[9].type.toString(), '() → Stream<int>');
}
void test_inferParameterType_setter_fromField() {
var mainUnit = checkFile('''
class C extends D {
/*error:INVALID_FIELD_OVERRIDE*/set foo(x) {}
}
class D {
int foo;
}
''');
var f = mainUnit.getType('C').accessors[0];
expect(f.type.toString(), '(int) → void');
}
void test_inferParameterType_setter_fromSetter() {
var mainUnit = checkFile('''
class C extends D {
set foo(x) {}
}
class D {
set foo(int x) {}
}
''');
var f = mainUnit.getType('C').accessors[0];
expect(f.type.toString(), '(int) → void');
}
void test_inferred_nonstatic_field_depends_on_static_field_complex() {
var mainUnit = checkFile('''
class C {
static var x = 'x';
var y = /*info:INFERRED_TYPE_LITERAL*/{
'a': /*info:INFERRED_TYPE_LITERAL*/{'b': 'c'},
'd': /*info:INFERRED_TYPE_LITERAL*/{'e': x}
};
}
''');
var x = mainUnit.getType('C').fields[0];
expect(x.name, 'x');
expect(x.type.toString(), 'String');
var y = mainUnit.getType('C').fields[1];
expect(y.name, 'y');
expect(y.type.toString(), 'Map<String, Map<String, String>>');
}
void test_inferred_nonstatic_field_depends_on_toplevel_var_simple() {
var mainUnit = checkFile('''
var x = 'x';
class C {
var y = x;
}
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'String');
var y = mainUnit.getType('C').fields[0];
expect(y.name, 'y');
expect(y.type.toString(), 'String');
}
void test_inferredInitializingFormalChecksDefaultValue() {
checkFile('''
class Foo {
var x = 1;
Foo([this.x = /*error:INVALID_ASSIGNMENT*/"1"]);
}''');
}
void test_inferredType_blockBodiedClosure_noArguments() {
var mainUnit = checkFile('''
class C {
static final v = () {};
}
''');
var v = mainUnit.getType('C').fields[0];
expect(v.type.toString(), '() → dynamic');
}
void test_inferredType_blockClosure_noArgs_noReturn() {
var mainUnit = checkFile('''
var f = () {};
''');
var f = mainUnit.topLevelVariables[0];
expect(f.type.toString(), '() → dynamic');
}
void test_inferredType_customBinaryOp() {
var mainUnit = checkFile('''
class C {
bool operator*(C other) => true;
}
C c;
var x = c*c;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_customBinaryOp_viaInterface() {
var mainUnit = checkFile('''
class I {
bool operator*(C other) => true;
}
abstract class C implements I {}
C c;
var x = c*c;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_customIndexOp() {
var mainUnit = checkFile('''
class C {
bool operator[](int index) => true;
}
C c;
var x = c[0];
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_customIndexOp_viaInterface() {
var mainUnit = checkFile('''
class I {
bool operator[](int index) => true;
}
abstract class C implements I {}
C c;
var x = c[0];
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_customUnaryOp() {
var mainUnit = checkFile('''
class C {
bool operator-() => true;
}
C c;
var x = -c;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_customUnaryOp_viaInterface() {
var mainUnit = checkFile('''
class I {
bool operator-() => true;
}
abstract class C implements I {}
C c;
var x = -c;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_extractMethodTearOff() {
var mainUnit = checkFile('''
class C {
bool g() => true;
}
C f() => null;
var x = f().g;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), '() → bool');
}
void test_inferredType_extractMethodTearOff_viaInterface() {
var mainUnit = checkFile('''
class I {
bool g() => true;
}
abstract class C implements I {}
C f() => null;
var x = f().g;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), '() → bool');
}
void test_inferredType_extractProperty() {
var mainUnit = checkFile('''
class C {
bool b;
}
C f() => null;
var x = f().b;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_extractProperty_prefixedIdentifier() {
var mainUnit = checkFile('''
class C {
bool b;
}
C c;
var x = c.b;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_extractProperty_prefixedIdentifier_viaInterface() {
var mainUnit = checkFile('''
class I {
bool b;
}
abstract class C implements I {}
C c;
var x = c.b;
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_extractProperty_viaInterface() {
var mainUnit = checkFile('''
class I {
bool b;
}
abstract class C implements I {}
C f() => null;
var x = f().b;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_fromTopLevelExecutableTearoff() {
var mainUnit = checkFile('''
var v = print;
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), '(Object) → void');
}
void test_inferredType_invokeMethod() {
var mainUnit = checkFile('''
class C {
bool g() => true;
}
C f() => null;
var x = f().g();
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_invokeMethod_viaInterface() {
var mainUnit = checkFile('''
class I {
bool g() => true;
}
abstract class C implements I {}
C f() => null;
var x = f().g();
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'bool');
}
void test_inferredType_isEnum() {
var mainUnit = checkFile('''
enum E { v1 }
final x = E.v1;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.type.toString(), 'E');
}
void test_inferredType_isEnumValues() {
var mainUnit = checkFile('''
enum E { v1 }
final x = E.values;
''');
var x = mainUnit.topLevelVariables[0];
expect(x.type.toString(), 'List<E>');
}
void test_inferredType_isTypedef() {
var mainUnit = checkFile('''
typedef void F();
final x = <String, F>{};
''');
var x = mainUnit.topLevelVariables[0];
expect(x.type.toString(), 'Map<String, () → void>');
}
void test_inferredType_isTypedef_parameterized() {
var mainUnit = checkFile('''
typedef T F<T>();
final x = <String, F<int>>{};
''');
var x = mainUnit.topLevelVariables[0];
expect(x.type.toString(), 'Map<String, () → int>');
}
void test_inferredType_opAssignToProperty() {
var mainUnit = checkFile('''
class C {
num n;
}
C f() => null;
var x = (f().n *= null);
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'num');
}
void test_inferredType_opAssignToProperty_prefixedIdentifier() {
var mainUnit = checkFile('''
class C {
num n;
}
C c;
var x = (c.n *= null);
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'num');
}
void test_inferredType_opAssignToProperty_prefixedIdentifier_viaInterface() {
var mainUnit = checkFile('''
class I {
num n;
}
abstract class C implements I {}
C c;
var x = (c.n *= null);
''');
var x = mainUnit.topLevelVariables[1];
expect(x.name, 'x');
expect(x.type.toString(), 'num');
}
void test_inferredType_opAssignToProperty_viaInterface() {
var mainUnit = checkFile('''
class I {
num n;
}
abstract class C implements I {}
C f() => null;
var x = (f().n *= null);
''');
var x = mainUnit.topLevelVariables[0];
expect(x.name, 'x');
expect(x.type.toString(), 'num');
}
void test_inferredType_viaClosure_multipleLevelsOfNesting() {
var mainUnit = checkFile('''
class C {
static final f = (bool b) => (int i) => /*info:INFERRED_TYPE_LITERAL*/{i: b};
}
''');
var f = mainUnit.getType('C').fields[0];
expect(f.type.toString(), '(bool) → (int) → Map<int, bool>');
}
void test_inferredType_viaClosure_typeDependsOnArgs() {
var mainUnit = checkFile('''
class C {
static final f = (bool b) => b;
}
''');
var f = mainUnit.getType('C').fields[0];
expect(f.type.toString(), '(bool) → bool');