| // 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_asyncClosureReturnType_futureOr() { |
| var mainUnit = checkFile(''' |
| import 'dart:async'; |
| FutureOr<int> futureOrInt = null; |
| var f = () => futureOrInt; |
| var g = () async => futureOrInt; |
| '''); |
| var futureOrInt = mainUnit.topLevelVariables[0]; |
| expect(futureOrInt.name, 'futureOrInt'); |
| expect(futureOrInt.type.toString(), 'FutureOr<int>'); |
| var f = mainUnit.topLevelVariables[1]; |
| expect(f.name, 'f'); |
| expect(f.type.toString(), '() → FutureOr<int>'); |
| var g = mainUnit.topLevelVariables[2]; |
| expect(g.name, 'g'); |
| expect(g.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_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_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_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(), |