| Index: pkg/analyzer_experimental/test/generated/resolver_test.dart
|
| diff --git a/pkg/analyzer_experimental/test/generated/resolver_test.dart b/pkg/analyzer_experimental/test/generated/resolver_test.dart
|
| index 81a1c4487af79ba28be6c78f9c131b06ce036fcd..708f070193239c122acb5885f80cc7da3a2084a7 100644
|
| --- a/pkg/analyzer_experimental/test/generated/resolver_test.dart
|
| +++ b/pkg/analyzer_experimental/test/generated/resolver_test.dart
|
| @@ -21,6 +21,26 @@ import 'test_support.dart';
|
| import 'ast_test.dart' show ASTFactory;
|
| import 'element_test.dart' show ElementFactory;
|
| class TypePropagationTest extends ResolverTestCase {
|
| + void fail_functionExpression_asInvocationArgument_functionExpressionInvocation() {
|
| + String code = EngineTestCase.createSource(["main() {", " (f(String value)) {} ((v) {", " v;", " });", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + Type2 dynamicType = typeProvider.dynamicType;
|
| + Type2 stringType = typeProvider.stringType;
|
| + FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", FormalParameter);
|
| + JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
|
| + JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
|
| + SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
|
| + JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
|
| + }
|
| + void fail_propagatedReturnType_functionExpression() {
|
| + String code = EngineTestCase.createSource(["main() {", " var v = (() {return 42;})();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| void test_as() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " bool get g => true;", "}", "A f(var p) {", " if ((p as A).g) {", " return p;", " } else {", " return null;", " }", "}"]));
|
| LibraryElement library = resolve(source);
|
| @@ -89,6 +109,83 @@ class TypePropagationTest extends ResolverTestCase {
|
| SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
|
| JUnitTestCase.assertSame(typeA, variableName.propagatedType);
|
| }
|
| + void test_functionExpression_asInvocationArgument() {
|
| + String code = EngineTestCase.createSource(["class MyMap<K, V> {", " forEach(f(K key, V value)) {}", "}", "f(MyMap<int, String> m) {", " m.forEach((k, v) {", " k;", " v;", " });", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + Type2 intType = typeProvider.intType;
|
| + FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
|
| + SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
|
| + JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
|
| + Type2 stringType = typeProvider.stringType;
|
| + FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
|
| + SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
|
| + JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
|
| + }
|
| + void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
|
| + String code = EngineTestCase.createSource(["class MyMap<K, V> {", " forEach(f(K key, V value)) {}", "}", "f(MyMap<int, String> m) {", " var m2 = m;", " m2.forEach((k, v) {});", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + Type2 intType = typeProvider.intType;
|
| + FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
|
| + Type2 stringType = typeProvider.stringType;
|
| + FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
|
| + }
|
| + void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
|
| + String code = EngineTestCase.createSource(["class MyList {", " forEach(f(Object value)) {}", "}", "f(MyList list) {", " list.forEach((int v) {", " v;", " });", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + Type2 intType = typeProvider.intType;
|
| + FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
|
| + JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
|
| + SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(intType, vIdentifier.staticType);
|
| + JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
|
| + }
|
| + void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
|
| + String code = EngineTestCase.createSource(["class MyList<E> {", " forEach(f(E value)) {}", "}", "f(MyList<String> list) {", " list.forEach((Object v) {", " v;", " });", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + Type2 stringType = typeProvider.stringType;
|
| + FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
|
| + JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
|
| + SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
|
| + }
|
| + void test_Future_then() {
|
| + String code = EngineTestCase.createSource(["import 'dart:async';", "main(Future<int> firstFuture) {", " firstFuture.then((p1) {", " return 1.0;", " }).then((p2) {", " return new Future<String>.value('str');", " }).then((p3) {", " });", "}"]);
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
|
| + FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
|
| + FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", SimpleFormalParameter);
|
| + JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
|
| + }
|
| void test_initializer() {
|
| Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return v;", "}"]));
|
| LibraryElement library = resolve(source);
|
| @@ -97,9 +194,18 @@ class TypePropagationTest extends ResolverTestCase {
|
| CompilationUnit unit = resolveCompilationUnit(source, library);
|
| FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
|
| BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
|
| - ReturnStatement statement = body.block.statements[1] as ReturnStatement;
|
| - SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
|
| - JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
|
| + NodeList<Statement> statements = body.block.statements;
|
| + {
|
| + VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
|
| + SimpleIdentifier variableName = statement.variables.variables[0].name;
|
| + JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
|
| + JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
|
| + }
|
| + {
|
| + ReturnStatement statement = statements[1] as ReturnStatement;
|
| + SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
|
| + JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
|
| + }
|
| }
|
| void test_initializer_dereference() {
|
| Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 'String';", " v.", "}"]));
|
| @@ -357,6 +463,34 @@ class TypePropagationTest extends ResolverTestCase {
|
| JUnitTestCase.assertSame(typeProvider.stringType, typeArguments[0]);
|
| JUnitTestCase.assertSame(typeProvider.intType, typeArguments[1]);
|
| }
|
| + void test_propagatedReturnType_function_hasReturnType_returnsNull() {
|
| + String code = EngineTestCase.createSource(["String f() => null;", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.stringType);
|
| + }
|
| + void test_propagatedReturnType_function_lessSpecificStaticReturnType() {
|
| + String code = EngineTestCase.createSource(["Object f() => 42;", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| + void test_propagatedReturnType_function_moreSpecificStaticReturnType() {
|
| + String code = EngineTestCase.createSource(["int f() => (42 as Object);", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| + void test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns() {
|
| + String code = EngineTestCase.createSource(["f() {", " if (true) return 0;", " return 1.0;", "}", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.numType);
|
| + }
|
| + void test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn() {
|
| + String code = EngineTestCase.createSource(["f() {", " var z = 42;", " return z;", "}", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| + void test_propagatedReturnType_function_noReturnTypeName_expressionBody() {
|
| + String code = EngineTestCase.createSource(["f() => 42;", "main() {", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| + void test_propagatedReturnType_localFunction() {
|
| + String code = EngineTestCase.createSource(["main() {", " f() => 42;", " var v = f();", "}"]);
|
| + check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
|
| + }
|
| void test_query() {
|
| Source source = addSource(EngineTestCase.createSource(["import 'dart:html';", "", "main() {", " var v1 = query('a');", " var v2 = query('A');", " var v3 = query('body:active');", " var v4 = query('button[foo=\"bar\"]');", " var v5 = query('div.class');", " var v6 = query('input#id');", " var v7 = query('select#id');", " // invocation of method", " var m1 = document.query('div');", " // unsupported currently", " var b1 = query('noSuchTag');", " var b2 = query('DART_EDITOR_NO_SUCH_TYPE');", " var b3 = query('body div');", " return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];", "}"]));
|
| LibraryElement library = resolve(source);
|
| @@ -379,8 +513,27 @@ class TypePropagationTest extends ResolverTestCase {
|
| JUnitTestCase.assertEquals("Element", elements[9].propagatedType.name);
|
| JUnitTestCase.assertEquals("Element", elements[10].propagatedType.name);
|
| }
|
| +
|
| + /**
|
| + * @param code the code that assigns the value to the variable "v", no matter how. We check that
|
| + * "v" has expected static and propagated type.
|
| + */
|
| + void check_propagatedReturnType(String code, Type2 expectedStaticType, Type2 expectedPropagatedType) {
|
| + Source source = addSource(code);
|
| + LibraryElement library = resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + CompilationUnit unit = resolveCompilationUnit(source, library);
|
| + SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = ", SimpleIdentifier);
|
| + JUnitTestCase.assertSame(expectedStaticType, identifier.staticType);
|
| + JUnitTestCase.assertSame(expectedPropagatedType, identifier.propagatedType);
|
| + }
|
| static dartSuite() {
|
| _ut.group('TypePropagationTest', () {
|
| + _ut.test('test_Future_then', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_Future_then);
|
| + });
|
| _ut.test('test_as', () {
|
| final __test = new TypePropagationTest();
|
| runJUnitTest(__test, __test.test_as);
|
| @@ -401,6 +554,22 @@ class TypePropagationTest extends ResolverTestCase {
|
| final __test = new TypePropagationTest();
|
| runJUnitTest(__test, __test.test_forEach);
|
| });
|
| + _ut.test('test_functionExpression_asInvocationArgument', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument);
|
| + });
|
| + _ut.test('test_functionExpression_asInvocationArgument_fromInferredInvocation', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_fromInferredInvocation);
|
| + });
|
| + _ut.test('test_functionExpression_asInvocationArgument_keepIfLessSpecific', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_keepIfLessSpecific);
|
| + });
|
| + _ut.test('test_functionExpression_asInvocationArgument_replaceIfMoreSpecific', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_replaceIfMoreSpecific);
|
| + });
|
| _ut.test('test_initializer', () {
|
| final __test = new TypePropagationTest();
|
| runJUnitTest(__test, __test.test_initializer);
|
| @@ -477,6 +646,34 @@ class TypePropagationTest extends ResolverTestCase {
|
| final __test = new TypePropagationTest();
|
| runJUnitTest(__test, __test.test_mapLiteral_same);
|
| });
|
| + _ut.test('test_propagatedReturnType_function_hasReturnType_returnsNull', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_hasReturnType_returnsNull);
|
| + });
|
| + _ut.test('test_propagatedReturnType_function_lessSpecificStaticReturnType', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_lessSpecificStaticReturnType);
|
| + });
|
| + _ut.test('test_propagatedReturnType_function_moreSpecificStaticReturnType', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_moreSpecificStaticReturnType);
|
| + });
|
| + _ut.test('test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns);
|
| + });
|
| + _ut.test('test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn);
|
| + });
|
| + _ut.test('test_propagatedReturnType_function_noReturnTypeName_expressionBody', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_expressionBody);
|
| + });
|
| + _ut.test('test_propagatedReturnType_localFunction', () {
|
| + final __test = new TypePropagationTest();
|
| + runJUnitTest(__test, __test.test_propagatedReturnType_localFunction);
|
| + });
|
| _ut.test('test_query', () {
|
| final __test = new TypePropagationTest();
|
| runJUnitTest(__test, __test.test_query);
|
| @@ -666,6 +863,19 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_constEval_propertyExtraction_fieldStatic_targetType() {
|
| + addSource2("/math.dart", EngineTestCase.createSource(["library math;", "const PI = 3.14;"]));
|
| + Source source = addSource(EngineTestCase.createSource(["import 'math.dart' as math;", "const C = math.PI;"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_constEval_propertyExtraction_methodStatic_targetType() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", " static m() {}", "}", "const C = A.m;"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_constEvalTypeBoolNumString_equal() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", "}", "class B {", " final v;", " const B.a1(bool p) : v = p == true;", " const B.a2(bool p) : v = p == false;", " const B.a3(bool p) : v = p == 0;", " const B.a4(bool p) : v = p == 0.0;", " const B.a5(bool p) : v = p == '';", " const B.b1(int p) : v = p == true;", " const B.b2(int p) : v = p == false;", " const B.b3(int p) : v = p == 0;", " const B.b4(int p) : v = p == 0.0;", " const B.b5(int p) : v = p == '';", " const B.c1(String p) : v = p == true;", " const B.c2(String p) : v = p == false;", " const B.c3(String p) : v = p == 0;", " const B.c4(String p) : v = p == 0.0;", " const B.c5(String p) : v = p == '';", " const B.n1(num p) : v = p == null;", " const B.n2(num p) : v = null == p;", "}"]));
|
| resolve(source);
|
| @@ -929,6 +1139,12 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_instanceMemberAccessFromStatic_fromComment() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", " /// [m]", " static foo() {", " }", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_invalidAssignment() {
|
| Source source = addSource(EngineTestCase.createSource(["f() {", " var x;", " var y;", " x = y;", "}"]));
|
| resolve(source);
|
| @@ -1073,6 +1289,24 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_invocationOfNonFunction_localVariable_dynamic() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", " var v = f;", " v();", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_invocationOfNonFunction_localVariable_dynamic2() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", " var v = f;", " v = 1;", " v();", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_invocationOfNonFunction_Object() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " Object v = null;", " v();", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_memberWithClassName_setter() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " set A(v) {}", "}"]));
|
| resolve(source);
|
| @@ -1457,6 +1691,12 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_staticAccessToInstanceMember_annotation() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A.name() {}", "}", "@A.name()", "main() {", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_staticAccessToInstanceMember_method() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " static m() {}", "}", "main() {", " A.m;", " A.m();", "}"]));
|
| resolve(source);
|
| @@ -1493,6 +1733,24 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_typeArgumentNotMatchingBounds_typeArgumentList_0() {
|
| + Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A>{}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_typeArgumentList_1() {
|
| + Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A>>{}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_typeArgumentList_20() {
|
| + Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A>>>>>>>>>>>>>>>>>>>>>{}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_undefinedConstructorInInitializer_explicit_named() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " A.named() {}", "}", "class B extends A {", " B() : super.named();", "}"]));
|
| resolve(source);
|
| @@ -1564,6 +1822,16 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| assertNoErrors();
|
| verify([source]);
|
| }
|
| + void test_undefinedMethod_functionExpression_callMethod() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " (() => null).call();", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + }
|
| + void test_undefinedMethod_functionExpression_directCall() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " (() => null)();", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + }
|
| void test_undefinedMethod_noSuchMethod() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " noSuchMethod(invocation) {}", "}", "f() {", " (new A()).m();", "}"]));
|
| resolve(source);
|
| @@ -1586,6 +1854,18 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| resolve(source);
|
| assertNoErrors();
|
| }
|
| + void test_undefinedSuperMethod_field() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " var m;", "}", "class B extends A {", " f() {", " super.m();", " }", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| + void test_undefinedSuperMethod_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", "}", "class B extends A {", " f() {", " super.m();", " }", "}"]));
|
| + resolve(source);
|
| + assertNoErrors();
|
| + verify([source]);
|
| + }
|
| void test_wrongNumberOfParametersForOperator_index() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " operator []=(a, b) {}", "}"]));
|
| resolve(source);
|
| @@ -1755,6 +2035,14 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_notEqual);
|
| });
|
| + _ut.test('test_constEval_propertyExtraction_fieldStatic_targetType', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_constEval_propertyExtraction_fieldStatic_targetType);
|
| + });
|
| + _ut.test('test_constEval_propertyExtraction_methodStatic_targetType', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetType);
|
| + });
|
| _ut.test('test_constWithNonConstantArgument_literals', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_constWithNonConstantArgument_literals);
|
| @@ -1919,6 +2207,10 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_initializingFormalForNonExistantField);
|
| });
|
| + _ut.test('test_instanceMemberAccessFromStatic_fromComment', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_fromComment);
|
| + });
|
| _ut.test('test_invalidAssignment', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_invalidAssignment);
|
| @@ -2003,6 +2295,10 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_invalidTypeArgumentInConstMap);
|
| });
|
| + _ut.test('test_invocationOfNonFunction_Object', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_invocationOfNonFunction_Object);
|
| + });
|
| _ut.test('test_invocationOfNonFunction_dynamic', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic);
|
| @@ -2015,6 +2311,14 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable);
|
| });
|
| + _ut.test('test_invocationOfNonFunction_localVariable_dynamic', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable_dynamic);
|
| + });
|
| + _ut.test('test_invocationOfNonFunction_localVariable_dynamic2', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable_dynamic2);
|
| + });
|
| _ut.test('test_memberWithClassName_setter', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_memberWithClassName_setter);
|
| @@ -2271,6 +2575,10 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_returnWithoutValue_void);
|
| });
|
| + _ut.test('test_staticAccessToInstanceMember_annotation', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_staticAccessToInstanceMember_annotation);
|
| + });
|
| _ut.test('test_staticAccessToInstanceMember_method', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_staticAccessToInstanceMember_method);
|
| @@ -2295,6 +2603,18 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
|
| });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_0', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_0);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_1', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_1);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_20', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_20);
|
| + });
|
| _ut.test('test_undefinedConstructorInInitializer_explicit_named', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_named);
|
| @@ -2343,6 +2663,14 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_undefinedIdentifier_show);
|
| });
|
| + _ut.test('test_undefinedMethod_functionExpression_callMethod', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_callMethod);
|
| + });
|
| + _ut.test('test_undefinedMethod_functionExpression_directCall', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_directCall);
|
| + });
|
| _ut.test('test_undefinedMethod_noSuchMethod', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_undefinedMethod_noSuchMethod);
|
| @@ -2359,6 +2687,14 @@ class NonErrorResolverTest extends ResolverTestCase {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_undefinedSetter_noSuchMethod);
|
| });
|
| + _ut.test('test_undefinedSuperMethod_field', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_undefinedSuperMethod_field);
|
| + });
|
| + _ut.test('test_undefinedSuperMethod_method', () {
|
| + final __test = new NonErrorResolverTest();
|
| + runJUnitTest(__test, __test.test_undefinedSuperMethod_method);
|
| + });
|
| _ut.test('test_wrongNumberOfParametersForOperator1', () {
|
| final __test = new NonErrorResolverTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator1);
|
| @@ -2406,51 +2742,21 @@ class LibraryTest extends EngineTestCase {
|
| _errorListener = new GatheringErrorListener();
|
| _library5 = library("/lib.dart");
|
| }
|
| - void test_addExport() {
|
| - Library exportLibrary = library("/exported.dart");
|
| - _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), exportLibrary);
|
| - List<Library> exports = _library5.exports;
|
| - EngineTestCase.assertLength(1, exports);
|
| - JUnitTestCase.assertSame(exportLibrary, exports[0]);
|
| - _errorListener.assertNoErrors();
|
| - }
|
| - void test_addImport() {
|
| - Library importLibrary = library("/imported.dart");
|
| - _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []), importLibrary);
|
| - List<Library> imports = _library5.imports;
|
| - EngineTestCase.assertLength(1, imports);
|
| - JUnitTestCase.assertSame(importLibrary, imports[0]);
|
| - _errorListener.assertNoErrors();
|
| - }
|
| void test_getExplicitlyImportsCore() {
|
| JUnitTestCase.assertFalse(_library5.explicitlyImportsCore);
|
| _errorListener.assertNoErrors();
|
| }
|
| - void test_getExport() {
|
| - ExportDirective directive = ASTFactory.exportDirective2("exported.dart", []);
|
| - Library exportLibrary = library("/exported.dart");
|
| - _library5.addExport(directive, exportLibrary);
|
| - JUnitTestCase.assertSame(exportLibrary, _library5.getExport(directive));
|
| - _errorListener.assertNoErrors();
|
| - }
|
| void test_getExports() {
|
| EngineTestCase.assertLength(0, _library5.exports);
|
| _errorListener.assertNoErrors();
|
| }
|
| - void test_getImport() {
|
| - ImportDirective directive = ASTFactory.importDirective2("imported.dart", null, []);
|
| - Library importLibrary = library("/imported.dart");
|
| - _library5.addImport(directive, importLibrary);
|
| - JUnitTestCase.assertSame(importLibrary, _library5.getImport(directive));
|
| - _errorListener.assertNoErrors();
|
| - }
|
| void test_getImports() {
|
| EngineTestCase.assertLength(0, _library5.imports);
|
| _errorListener.assertNoErrors();
|
| }
|
| void test_getImportsAndExports() {
|
| - _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []), library("/imported.dart"));
|
| - _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), library("/exported.dart"));
|
| + _library5.importedLibraries = <Library> [library("/imported.dart")];
|
| + _library5.exportedLibraries = <Library> [library("/exported.dart")];
|
| EngineTestCase.assertLength(2, _library5.importsAndExports);
|
| _errorListener.assertNoErrors();
|
| }
|
| @@ -2469,6 +2775,22 @@ class LibraryTest extends EngineTestCase {
|
| JUnitTestCase.assertTrue(_library5.explicitlyImportsCore);
|
| _errorListener.assertNoErrors();
|
| }
|
| + void test_setExportedLibraries() {
|
| + Library exportLibrary = library("/exported.dart");
|
| + _library5.exportedLibraries = <Library> [exportLibrary];
|
| + List<Library> exports = _library5.exports;
|
| + EngineTestCase.assertLength(1, exports);
|
| + JUnitTestCase.assertSame(exportLibrary, exports[0]);
|
| + _errorListener.assertNoErrors();
|
| + }
|
| + void test_setImportedLibraries() {
|
| + Library importLibrary = library("/imported.dart");
|
| + _library5.importedLibraries = <Library> [importLibrary];
|
| + List<Library> imports = _library5.imports;
|
| + EngineTestCase.assertLength(1, imports);
|
| + JUnitTestCase.assertSame(importLibrary, imports[0]);
|
| + _errorListener.assertNoErrors();
|
| + }
|
| void test_setLibraryElement() {
|
| LibraryElementImpl element = new LibraryElementImpl(_analysisContext, ASTFactory.libraryIdentifier2(["lib"]));
|
| _library5.libraryElement = element;
|
| @@ -2477,30 +2799,14 @@ class LibraryTest extends EngineTestCase {
|
| Library library(String definingCompilationUnitPath) => new Library(_analysisContext, _errorListener, new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(definingCompilationUnitPath)));
|
| static dartSuite() {
|
| _ut.group('LibraryTest', () {
|
| - _ut.test('test_addExport', () {
|
| - final __test = new LibraryTest();
|
| - runJUnitTest(__test, __test.test_addExport);
|
| - });
|
| - _ut.test('test_addImport', () {
|
| - final __test = new LibraryTest();
|
| - runJUnitTest(__test, __test.test_addImport);
|
| - });
|
| _ut.test('test_getExplicitlyImportsCore', () {
|
| final __test = new LibraryTest();
|
| runJUnitTest(__test, __test.test_getExplicitlyImportsCore);
|
| });
|
| - _ut.test('test_getExport', () {
|
| - final __test = new LibraryTest();
|
| - runJUnitTest(__test, __test.test_getExport);
|
| - });
|
| _ut.test('test_getExports', () {
|
| final __test = new LibraryTest();
|
| runJUnitTest(__test, __test.test_getExports);
|
| });
|
| - _ut.test('test_getImport', () {
|
| - final __test = new LibraryTest();
|
| - runJUnitTest(__test, __test.test_getImport);
|
| - });
|
| _ut.test('test_getImports', () {
|
| final __test = new LibraryTest();
|
| runJUnitTest(__test, __test.test_getImports);
|
| @@ -2521,6 +2827,14 @@ class LibraryTest extends EngineTestCase {
|
| final __test = new LibraryTest();
|
| runJUnitTest(__test, __test.test_setExplicitlyImportsCore);
|
| });
|
| + _ut.test('test_setExportedLibraries', () {
|
| + final __test = new LibraryTest();
|
| + runJUnitTest(__test, __test.test_setExportedLibraries);
|
| + });
|
| + _ut.test('test_setImportedLibraries', () {
|
| + final __test = new LibraryTest();
|
| + runJUnitTest(__test, __test.test_setImportedLibraries);
|
| + });
|
| _ut.test('test_setLibraryElement', () {
|
| final __test = new LibraryTest();
|
| runJUnitTest(__test, __test.test_setLibraryElement);
|
| @@ -2535,24 +2849,12 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]);
|
| verify([source]);
|
| }
|
| - void fail_nonTypeAsTypeArgument() {
|
| - Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
|
| - resolve(source);
|
| - assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
|
| - verify([source]);
|
| - }
|
| void fail_redirectWithInvalidTypeParameters() {
|
| Source source = addSource(EngineTestCase.createSource([]));
|
| resolve(source);
|
| assertErrors([StaticTypeWarningCode.REDIRECT_WITH_INVALID_TYPE_PARAMETERS]);
|
| verify([source]);
|
| }
|
| - void fail_typeArgumentViolatesBounds() {
|
| - Source source = addSource(EngineTestCase.createSource([]));
|
| - resolve(source);
|
| - assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_VIOLATES_BOUNDS]);
|
| - verify([source]);
|
| - }
|
| void test_inconsistentMethodInheritance_paramCount() {
|
| Source source = addSource(EngineTestCase.createSource(["abstract class A {", " int x();", "}", "abstract class B {", " int x(int y);", "}", "class C implements A, B {", "}"]));
|
| resolve(source);
|
| @@ -2658,6 +2960,18 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
|
| verify([source]);
|
| }
|
| + void test_nonTypeAsTypeArgument_notAType() {
|
| + Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
|
| + verify([source]);
|
| + }
|
| + void test_nonTypeAsTypeArgument_undefinedIdentifier() {
|
| + Source source = addSource(EngineTestCase.createSource(["class B<E> {}", "f(B<A> b) {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
|
| + verify([source]);
|
| + }
|
| void test_returnOfInvalidType_expressionFunctionBody_function() {
|
| Source source = addSource(EngineTestCase.createSource(["int f() => '0';"]));
|
| resolve(source);
|
| @@ -2718,18 +3032,108 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
|
| verify([source]);
|
| }
|
| + void test_typeArgumentNotMatchingBounds_classTypeAlias() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class C {}", "class G<E extends A> {}", "typedef D = G<B> with C;"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| void test_typeArgumentNotMatchingBounds_const() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {", " const G();", "}", "f() { return const G<B>(); }"]));
|
| resolve(source);
|
| assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| verify([source]);
|
| }
|
| + void test_typeArgumentNotMatchingBounds_extends() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C extends G<B>{}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_fieldFormalParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C {", " var f;", " C(G<B> this.f) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_functionReturnType() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> f() {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "typedef G<B> f();"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_functionTypedFormalParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> h()) {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_implements() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C implements G<B>{}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_is() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "var b = 1 is G<B>;"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_methodReturnType() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C {", " G<B> m() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| void test_typeArgumentNotMatchingBounds_new() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f() { return new G<B>(); }"]));
|
| resolve(source);
|
| assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| verify([source]);
|
| }
|
| + void test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "class C extends B {}", "class G<E extends B> {}", "f() { return new G<A>(); }"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_parameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> g) {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_typeArgumentList() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class C<E> {}", "class D<E extends A> {}", "C<D<B>> Var;"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_typeParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class C {}", "class G<E extends A> {}", "class D<F extends G<B>> {}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_variableDeclaration() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> g;"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| + void test_typeArgumentNotMatchingBounds_with() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C extends Object with G<B>{}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
|
| + verify([source]);
|
| + }
|
| void test_undefinedFunction() {
|
| Source source = addSource(EngineTestCase.createSource(["void f() {", " g();", "}"]));
|
| resolve(source);
|
| @@ -2802,6 +3206,18 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| verify([source]);
|
| }
|
| + void test_wrongNumberOfTypeArguments_typeTest_tooFew() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", " return p is C<A>;", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| + void test_wrongNumberOfTypeArguments_typeTest_tooMany() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", " return p is C<A, A>;", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| static dartSuite() {
|
| _ut.group('StaticTypeWarningCodeTest', () {
|
| _ut.test('test_inconsistentMethodInheritance_paramCount', () {
|
| @@ -2876,6 +3292,14 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_nonBoolExpression);
|
| });
|
| + _ut.test('test_nonTypeAsTypeArgument_notAType', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_notAType);
|
| + });
|
| + _ut.test('test_nonTypeAsTypeArgument_undefinedIdentifier', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_undefinedIdentifier);
|
| + });
|
| _ut.test('test_returnOfInvalidType_expressionFunctionBody_function', () {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_function);
|
| @@ -2916,14 +3340,74 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_returnOfInvalidType_void);
|
| });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_classTypeAlias', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_classTypeAlias);
|
| + });
|
| _ut.test('test_typeArgumentNotMatchingBounds_const', () {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
|
| });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_extends', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_extends);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_fieldFormalParameter', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_fieldFormalParameter);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_functionReturnType', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionReturnType);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_functionTypeAlias', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionTypeAlias);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_functionTypedFormalParameter', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionTypedFormalParameter);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_implements', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_implements);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_is', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_is);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_methodReturnType', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_methodReturnType);
|
| + });
|
| _ut.test('test_typeArgumentNotMatchingBounds_new', () {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
|
| });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_parameter', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_parameter);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_typeParameter', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeParameter);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_variableDeclaration', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_variableDeclaration);
|
| + });
|
| + _ut.test('test_typeArgumentNotMatchingBounds_with', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_with);
|
| + });
|
| _ut.test('test_undefinedFunction', () {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_undefinedFunction);
|
| @@ -2980,6 +3464,14 @@ class StaticTypeWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticTypeWarningCodeTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_tooMany);
|
| });
|
| + _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooFew', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooFew);
|
| + });
|
| + _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooMany', () {
|
| + final __test = new StaticTypeWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooMany);
|
| + });
|
| });
|
| }
|
| }
|
| @@ -3193,11 +3685,12 @@ class TypeResolverVisitorTest extends EngineTestCase {
|
| * Analyze the given catch clause and assert that the types of the parameters have been set to the
|
| * given types. The types can be null if the catch clause does not have the corresponding
|
| * parameter.
|
| + *
|
| * @param node the catch clause to be analyzed
|
| * @param exceptionType the expected type of the exception parameter
|
| * @param stackTraceType the expected type of the stack trace parameter
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| */
|
| void resolve(CatchClause node, InterfaceType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
|
| resolveNode(node, definedElements);
|
| @@ -3214,9 +3707,10 @@ class TypeResolverVisitorTest extends EngineTestCase {
|
| /**
|
| * Return the type associated with the given parameter after the static type analyzer has computed
|
| * a type for it.
|
| + *
|
| * @param node the parameter with which the type is associated
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| * @return the type associated with the parameter
|
| */
|
| Type2 resolve6(FormalParameter node, List<Element> definedElements) {
|
| @@ -3227,9 +3721,10 @@ class TypeResolverVisitorTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the given identifier after the resolver has resolved the
|
| * identifier.
|
| + *
|
| * @param node the expression to be resolved
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| * @return the element to which the expression was resolved
|
| */
|
| void resolveNode(ASTNode node, List<Element> definedElements) {
|
| @@ -3294,7 +3789,7 @@ class TypeResolverVisitorTest extends EngineTestCase {
|
| class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| - * The source factory used to create [Source sources].
|
| + * The source factory used to create [Source].
|
| */
|
| SourceFactory _sourceFactory;
|
|
|
| @@ -3308,6 +3803,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Add a source file to the content provider.
|
| + *
|
| * @param contents the contents to be returned by the content provider for the specified file
|
| * @return the source object representing the added file
|
| */
|
| @@ -3315,6 +3811,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Add a source file to the content provider. The file path should be absolute.
|
| + *
|
| * @param filePath the path of the file being added
|
| * @param contents the contents to be returned by the content provider for the specified file
|
| * @return the source object representing the added file
|
| @@ -3331,9 +3828,10 @@ class ResolverTestCase extends EngineTestCase {
|
| * Assert that the number of errors that have been gathered matches the number of errors that are
|
| * given and that they have the expected error codes. The order in which the errors were gathered
|
| * is ignored.
|
| + *
|
| * @param expectedErrorCodes the error codes of the errors that should have been gathered
|
| * @throws AssertionFailedError if a different number of errors have been gathered than were
|
| - * expected
|
| + * expected
|
| */
|
| void assertErrors(List<ErrorCode> expectedErrorCodes) {
|
| GatheringErrorListener errorListener = new GatheringErrorListener();
|
| @@ -3347,6 +3845,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Assert that no errors have been gathered.
|
| + *
|
| * @throws AssertionFailedError if any errors have been gathered
|
| */
|
| void assertNoErrors() {
|
| @@ -3362,6 +3861,7 @@ class ResolverTestCase extends EngineTestCase {
|
| /**
|
| * Cache the source file content in the source factory but don't add the source to the analysis
|
| * context. The file path should be absolute.
|
| + *
|
| * @param filePath the path of the file being cached
|
| * @param contents the contents to be returned by the content provider for the specified file
|
| * @return the source object representing the cached file
|
| @@ -3375,6 +3875,7 @@ class ResolverTestCase extends EngineTestCase {
|
| /**
|
| * Create a library element that represents a library named `"test"` containing a single
|
| * empty compilation unit.
|
| + *
|
| * @return the library element that was created
|
| */
|
| LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
|
| @@ -3382,6 +3883,7 @@ class ResolverTestCase extends EngineTestCase {
|
| /**
|
| * Create a library element that represents a library with the given name containing a single
|
| * empty compilation unit.
|
| + *
|
| * @param libraryName the name of the library to be created
|
| * @return the library element that was created
|
| */
|
| @@ -3410,6 +3912,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Return a type provider that can be used to test the results of resolution.
|
| + *
|
| * @return a type provider
|
| */
|
| TypeProvider get typeProvider {
|
| @@ -3431,6 +3934,7 @@ class ResolverTestCase extends EngineTestCase {
|
| * Given a library and all of its parts, resolve the contents of the library and the contents of
|
| * the parts. This assumes that the sources for the library and its parts have already been added
|
| * to the content provider using the method [addSource].
|
| + *
|
| * @param librarySource the source for the compilation unit that defines the library
|
| * @return the element representing the resolved library
|
| * @throws AnalysisException if the analysis could not be performed
|
| @@ -3439,6 +3943,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Return the resolved compilation unit corresponding to the given source in the given library.
|
| + *
|
| * @param source the source of the compilation unit to be returned
|
| * @param library the library in which the compilation unit is to be resolved
|
| * @return the resolved compilation unit
|
| @@ -3449,8 +3954,9 @@ class ResolverTestCase extends EngineTestCase {
|
| /**
|
| * Verify that all of the identifiers in the compilation units associated with the given sources
|
| * have been resolved.
|
| + *
|
| * @param resolvedElementMap a table mapping the AST nodes that have been resolved to the element
|
| - * to which they were resolved
|
| + * to which they were resolved
|
| * @param sources the sources identifying the compilation units to be verified
|
| * @throws Exception if the contents of the compilation unit cannot be accessed
|
| */
|
| @@ -3464,6 +3970,7 @@ class ResolverTestCase extends EngineTestCase {
|
|
|
| /**
|
| * Create a source object representing a file with the given name and give it an empty content.
|
| + *
|
| * @param fileName the name of the file for which a source is to be created
|
| * @return the source that was created
|
| */
|
| @@ -3489,9 +3996,10 @@ class TypeProviderImplTest extends EngineTestCase {
|
| InterfaceType mapType = classElement("Map", objectType, ["K", "V"]).type;
|
| InterfaceType stackTraceType = classElement("StackTrace", objectType, []).type;
|
| InterfaceType stringType = classElement("String", objectType, []).type;
|
| + InterfaceType symbolType = classElement("Symbol", objectType, []).type;
|
| InterfaceType typeType = classElement("Type", objectType, []).type;
|
| CompilationUnitElementImpl unit = new CompilationUnitElementImpl("lib.dart");
|
| - unit.types = <ClassElement> [boolType.element, doubleType.element, functionType.element, intType.element, listType.element, mapType.element, objectType.element, stackTraceType.element, stringType.element, typeType.element];
|
| + unit.types = <ClassElement> [boolType.element, doubleType.element, functionType.element, intType.element, listType.element, mapType.element, objectType.element, stackTraceType.element, stringType.element, symbolType.element, typeType.element];
|
| LibraryElementImpl library = new LibraryElementImpl(new AnalysisContextImpl(), ASTFactory.libraryIdentifier2(["lib"]));
|
| library.definingCompilationUnit = unit;
|
| TypeProviderImpl provider = new TypeProviderImpl(library);
|
| @@ -3506,6 +4014,7 @@ class TypeProviderImplTest extends EngineTestCase {
|
| JUnitTestCase.assertSame(objectType, provider.objectType);
|
| JUnitTestCase.assertSame(stackTraceType, provider.stackTraceType);
|
| JUnitTestCase.assertSame(stringType, provider.stringType);
|
| + JUnitTestCase.assertSame(symbolType, provider.symbolType);
|
| JUnitTestCase.assertSame(typeType, provider.typeType);
|
| }
|
| ClassElement classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
|
| @@ -3858,6 +4367,7 @@ class InheritanceManagerTest extends EngineTestCase {
|
|
|
| /**
|
| * Create the inheritance manager used by the tests.
|
| + *
|
| * @return the inheritance manager that was created
|
| */
|
| InheritanceManager createInheritanceManager() {
|
| @@ -3999,36 +4509,6 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
|
| verify([source]);
|
| }
|
| - void fail_duplicateDefinition() {
|
| - Source source = addSource(EngineTestCase.createSource(["f() {", " int m = 0;", " m(a) {}", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| - verify([source]);
|
| - }
|
| - void fail_duplicateMemberError_classMembers_fields() {
|
| - Source librarySource = addSource(EngineTestCase.createSource(["class A {", " int a;", " int a;", "}"]));
|
| - resolve(librarySource);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| - verify([librarySource]);
|
| - }
|
| - void fail_duplicateMemberError_localFields() {
|
| - Source librarySource = addSource(EngineTestCase.createSource(["class A {", " m() {", " int a;", " int a;", " }", "}"]));
|
| - resolve(librarySource);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| - verify([librarySource]);
|
| - }
|
| - void fail_duplicateMemberName() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " int x = 0;", " int x() {}", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME]);
|
| - verify([source]);
|
| - }
|
| - void fail_duplicateMemberNameInstanceStatic() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " static int x;", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME_INSTANCE_STATIC]);
|
| - verify([source]);
|
| - }
|
| void fail_extendsOrImplementsDisallowedClass_extends_null() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends Null {}"]));
|
| resolve(source);
|
| @@ -4041,12 +4521,6 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
|
| verify([source]);
|
| }
|
| - void fail_invalidOverrideDefaultValue() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " m([a = 0]) {}", "}", "class B extends A {", " m([a = 1]) {}", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_DEFAULT_VALUE]);
|
| - verify([source]);
|
| - }
|
| void fail_mixinDeclaresConstructor() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", "}", "class B extends Object mixin A {}"]));
|
| resolve(source);
|
| @@ -4113,42 +4587,6 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.UNINITIALIZED_FINAL_FIELD]);
|
| verify([source]);
|
| }
|
| - void fail_wrongNumberOfTypeArguments_creation_const_tooFew() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", " return const C<A>();", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| - void fail_wrongNumberOfTypeArguments_creation_const_tooMany() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", " return const C<A, A>();", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| - void fail_wrongNumberOfTypeArguments_creation_new_tooFew() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", " return new C<A>();", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| - void fail_wrongNumberOfTypeArguments_creation_new_tooMany() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", " return new C<A, A>();", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| - void fail_wrongNumberOfTypeArguments_typeTest_tooFew() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", " return p is C<A>;", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| - void fail_wrongNumberOfTypeArguments_typeTest_tooMany() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", " return p is C<A, A>;", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
|
| - verify([source]);
|
| - }
|
| void test_ambiguousExport() {
|
| Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart';"]));
|
| addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| @@ -4264,7 +4702,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| verify([source]);
|
| }
|
| void test_caseExpressionTypeImplementsEquals() {
|
| - Source source = addSource(EngineTestCase.createSource(["class IntWrapper {", " final int value;", " const IntWrapper(this.value);", " bool operator ==(IntWrapper x) {", " return value == x.value;", " }", "}", "", "f(IntWrapper a) {", " switch(a) {", " case(const IntWrapper(1)) : return 1;", " default: return 0;", " }", "}"]));
|
| + Source source = addSource(EngineTestCase.createSource(["class IntWrapper {", " final int value;", " const IntWrapper(this.value);", " bool operator ==(IntWrapper x) {", " return value == x.value;", " }", "}", "", "f(var a) {", " switch(a) {", " case(const IntWrapper(1)) : return 1;", " default: return 0;", " }", "}"]));
|
| resolve(source);
|
| assertErrors([CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
|
| verify([source]);
|
| @@ -4281,6 +4719,30 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD]);
|
| verify([source]);
|
| }
|
| + void test_conflictingGetterAndMethod_field_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " int m;", "}", "class B extends A {", " m() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
|
| + verify([source]);
|
| + }
|
| + void test_conflictingGetterAndMethod_getter_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " get m => 0;", "}", "class B extends A {", " m() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
|
| + verify([source]);
|
| + }
|
| + void test_conflictingGetterAndMethod_method_field() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", "}", "class B extends A {", " int m;", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
|
| + verify([source]);
|
| + }
|
| + void test_conflictingGetterAndMethod_method_getter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", "}", "class B extends A {", " get m => 0;", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
|
| + verify([source]);
|
| + }
|
| void test_constConstructorWithNonFinalField_mixin() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " var a;", "}", "class B extends Object with A {", " const B();", "}"]));
|
| resolve(source);
|
| @@ -4299,6 +4761,24 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
|
| verify([source]);
|
| }
|
| + void test_constEval_newInstance_constConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", "}", "const a = new A();"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
|
| + verify([source]);
|
| + }
|
| + void test_constEval_propertyExtraction_methodInstance() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", " m() {}", "}", "final a = const A();", "const C = a.m;"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
|
| + verify([source]);
|
| + }
|
| + void test_constEval_propertyExtraction_methodStatic_targetInstance() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", " static m() {}", "}", "final a = const A();", "const C = a.m;"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
|
| + verify([source]);
|
| + }
|
| void test_constEvalThrowsException_binaryMinus_null() {
|
| check_constEvalThrowsException_binary_null("null - 5", false);
|
| check_constEvalThrowsException_binary_null("5 - null", true);
|
| @@ -4307,6 +4787,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| check_constEvalThrowsException_binary_null("null + 5", false);
|
| check_constEvalThrowsException_binary_null("5 + null", true);
|
| }
|
| + void test_constEvalThrowsException_divisionByZero() {
|
| + Source source = addSource("const C = 1 ~/ 0;");
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE]);
|
| + verify([source]);
|
| + }
|
| void test_constEvalThrowsException_unaryBitNot_null() {
|
| Source source = addSource("const C = ~null;");
|
| resolve(source);
|
| @@ -4327,6 +4813,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| check_constEvalTypeBool_withParameter_binary("p && ''");
|
| check_constEvalTypeBool_withParameter_binary("p || ''");
|
| }
|
| + void test_constEvalTypeBool_binary_leftTrue() {
|
| + Source source = addSource("const C = (true || 0);");
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
|
| + verify([source]);
|
| + }
|
| void test_constEvalTypeBoolNumString_equal() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", "}", "class B {", " final a;", " const B(num p) : a = p == const A();", "}"]));
|
| resolve(source);
|
| @@ -4400,6 +4892,18 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
|
| verify([source]);
|
| }
|
| + void test_constWithInvalidTypeParameters_tooFew() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {", " const C();", "}", "f(p) {", " return const C<A>();", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
|
| + verify([source]);
|
| + }
|
| + void test_constWithInvalidTypeParameters_tooMany() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {", " const C();", "}", "f(p) {", " return const C<A, A>();", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
|
| + verify([source]);
|
| + }
|
| void test_constWithNonConst() {
|
| Source source = addSource(EngineTestCase.createSource(["class T {", " T(a, b, {c, d}) {}", "}", "f() { return const T(0, 1, c: 2, d: 3); }"]));
|
| resolve(source);
|
| @@ -4418,6 +4922,14 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
|
| verify([source]);
|
| }
|
| + void test_constWithNonType_fromLibrary() {
|
| + Source source1 = addSource2("lib.dart", "");
|
| + Source source2 = addSource2("lib2.dart", EngineTestCase.createSource(["import 'lib.dart' as lib;", "void f() {", " const lib.A();", "}"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
|
| + verify([source1]);
|
| + }
|
| void test_constWithTypeParameters_direct() {
|
| Source source = addSource(EngineTestCase.createSource(["class A<T> {", " static const V = const A<T>();", " const A();", "}"]));
|
| resolve(source);
|
| @@ -4447,17 +4959,55 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
|
| verify([source]);
|
| }
|
| - void test_duplicateConstructorName_named() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " A.a() {}", " A.a() {}", "}"]));
|
| + void test_duplicateConstructorName_named() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A.a() {}", " A.a() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME]);
|
| + verify([source]);
|
| + }
|
| + void test_duplicateConstructorName_unnamed() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", " A() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT]);
|
| + verify([source]);
|
| + }
|
| + void test_duplicateDefinition() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " int m = 0;", " m(a) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| + verify([source]);
|
| + }
|
| + void test_duplicateDefinition_acrossLibraries() {
|
| + Source librarySource = addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
|
| + Source sourceA = addSource2("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
|
| + Source sourceB = addSource2("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
|
| + resolve(librarySource);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| + verify([librarySource, sourceA, sourceB]);
|
| + }
|
| + void test_duplicateDefinition_classMembers_fields() {
|
| + Source librarySource = addSource(EngineTestCase.createSource(["class A {", " int a;", " int a;", "}"]));
|
| + resolve(librarySource);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| + verify([librarySource]);
|
| + }
|
| + void test_duplicateDefinition_classMembers_fields_oneStatic() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " static int x;", "}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME]);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| verify([source]);
|
| }
|
| - void test_duplicateConstructorName_unnamed() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", " A() {}", "}"]));
|
| - resolve(source);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT]);
|
| - verify([source]);
|
| + void test_duplicateDefinition_classMembers_methods() {
|
| + Source librarySource = addSource(EngineTestCase.createSource(["class A {", " m() {}", " m() {}", "}"]));
|
| + resolve(librarySource);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| + verify([librarySource]);
|
| + }
|
| + void test_duplicateDefinition_localFields() {
|
| + Source librarySource = addSource(EngineTestCase.createSource(["class A {", " m() {", " int a;", " int a;", " }", "}"]));
|
| + resolve(librarySource);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| + verify([librarySource]);
|
| }
|
| void test_duplicateDefinition_parameterWithFunctionName_local() {
|
| Source source = addSource(EngineTestCase.createSource(["main() {", " f(f) {}", "}"]));
|
| @@ -4471,19 +5021,17 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| verify([source]);
|
| }
|
| - void test_duplicateMemberError() {
|
| - Source librarySource = addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
|
| - Source sourceA = addSource2("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
|
| - Source sourceB = addSource2("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
|
| - resolve(librarySource);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| - verify([librarySource, sourceA, sourceB]);
|
| + void test_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " x() {}", "}", "class B extends A {", " static x() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
|
| + verify([source]);
|
| }
|
| - void test_duplicateMemberError_classMembers_methods() {
|
| - Source librarySource = addSource(EngineTestCase.createSource(["class A {", " m() {}", " m() {}", "}"]));
|
| - resolve(librarySource);
|
| - assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
|
| - verify([librarySource]);
|
| + void test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
|
| + Source source = addSource(EngineTestCase.createSource(["abstract class A {", " x();", "}", "abstract class B extends A {", " static x() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
|
| + verify([source]);
|
| }
|
| void test_duplicateNamedArgument() {
|
| Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", " f(a: 1, a: 2);", "}"]));
|
| @@ -4513,31 +5061,31 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| void test_extendsOrImplementsDisallowedClass_extends_bool() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends bool {}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| verify([source]);
|
| }
|
| void test_extendsOrImplementsDisallowedClass_extends_double() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends double {}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| verify([source]);
|
| }
|
| void test_extendsOrImplementsDisallowedClass_extends_int() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends int {}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| verify([source]);
|
| }
|
| void test_extendsOrImplementsDisallowedClass_extends_num() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends num {}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| verify([source]);
|
| }
|
| void test_extendsOrImplementsDisallowedClass_extends_String() {
|
| Source source = addSource(EngineTestCase.createSource(["class A extends String {}"]));
|
| resolve(source);
|
| - assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| verify([source]);
|
| }
|
| void test_extendsOrImplementsDisallowedClass_implements_bool() {
|
| @@ -4739,6 +5287,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
|
| verify([source]);
|
| }
|
| + void test_implicitThisReferenceInInitializer_field2() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " final x = 0;", " final y = x;", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
|
| + verify([source]);
|
| + }
|
| void test_implicitThisReferenceInInitializer_invocation() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " var v;", " A() : v = f();", " f() {}", "}"]));
|
| resolve(source);
|
| @@ -4823,6 +5377,24 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
|
| verify([source]);
|
| }
|
| + void test_instanceMemberAccessFromStatic_field() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " int f;", " static foo() {", " f;", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
|
| + verify([source]);
|
| + }
|
| + void test_instanceMemberAccessFromStatic_getter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " get g => null;", " static foo() {", " g;", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
|
| + verify([source]);
|
| + }
|
| + void test_instanceMemberAccessFromStatic_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", " static foo() {", " m();", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
|
| + verify([source]);
|
| + }
|
| void test_invalidConstructorName_notEnclosingClassName() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " B() : super();", "}"]));
|
| resolve(source);
|
| @@ -5075,6 +5647,36 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
|
| verify([source]);
|
| }
|
| + void test_newWithInvalidTypeParameters_tooFew() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", " return new C<A>();", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
|
| + verify([source]);
|
| + }
|
| + void test_newWithInvalidTypeParameters_tooMany() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", " return new C<A, A>();", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
|
| + verify([source]);
|
| + }
|
| + void test_noDefaultSuperConstructorExplicit() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A(p);", "}", "class B extends A {", " B() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
|
| + verify([source]);
|
| + }
|
| + void test_noDefaultSuperConstructorImplicit_superHasParameters() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A(p);", "}", "class B extends A {", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + verify([source]);
|
| + }
|
| + void test_noDefaultSuperConstructorImplicit_superOnlyNamed() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A { A.named() {} }", "class B extends A {}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| + verify([source]);
|
| + }
|
| void test_nonConstantDefaultValue_function_named() {
|
| Source source = addSource(EngineTestCase.createSource(["int y;", "f({x : y}) {}"]));
|
| resolve(source);
|
| @@ -5201,6 +5803,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
|
| verify([source]);
|
| }
|
| + void test_nonGenerativeConstructor_implicit2() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " factory A() {}", "}", "class B extends A {", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
|
| + verify([source]);
|
| + }
|
| void test_notEnoughRequiredArguments_const() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " const A(int p);", "}", "main() {", " const A();", "}"]));
|
| resolve(source);
|
| @@ -5536,6 +6144,18 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| check_wrongNumberOfParametersForOperator1(">>");
|
| check_wrongNumberOfParametersForOperator1("[]");
|
| }
|
| + void test_wrongNumberOfParametersForSetter_function_named() {
|
| + Source source = addSource("set x({p}) {}");
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| + void test_wrongNumberOfParametersForSetter_function_optional() {
|
| + Source source = addSource("set x([p]) {}");
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| void test_wrongNumberOfParametersForSetter_function_tooFew() {
|
| Source source = addSource("set x() {}");
|
| resolve(source);
|
| @@ -5548,6 +6168,18 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
|
| verify([source]);
|
| }
|
| + void test_wrongNumberOfParametersForSetter_method_named() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " set x({p}) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| + void test_wrongNumberOfParametersForSetter_method_optional() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " set x([p]) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| void test_wrongNumberOfParametersForSetter_method_tooFew() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " set x() {}", "}"]));
|
| resolve(source);
|
| @@ -5685,6 +6317,22 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_method);
|
| });
|
| + _ut.test('test_conflictingGetterAndMethod_field_method', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_conflictingGetterAndMethod_field_method);
|
| + });
|
| + _ut.test('test_conflictingGetterAndMethod_getter_method', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_conflictingGetterAndMethod_getter_method);
|
| + });
|
| + _ut.test('test_conflictingGetterAndMethod_method_field', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_conflictingGetterAndMethod_method_field);
|
| + });
|
| + _ut.test('test_conflictingGetterAndMethod_method_getter', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_conflictingGetterAndMethod_method_getter);
|
| + });
|
| _ut.test('test_constConstructorWithNonFinalField_mixin', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_mixin);
|
| @@ -5705,6 +6353,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constEvalThrowsException_binaryPlus_null);
|
| });
|
| + _ut.test('test_constEvalThrowsException_divisionByZero', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constEvalThrowsException_divisionByZero);
|
| + });
|
| _ut.test('test_constEvalThrowsException_unaryBitNot_null', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constEvalThrowsException_unaryBitNot_null);
|
| @@ -5729,6 +6381,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constEvalTypeBool_binary);
|
| });
|
| + _ut.test('test_constEvalTypeBool_binary_leftTrue', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constEvalTypeBool_binary_leftTrue);
|
| + });
|
| _ut.test('test_constEvalTypeInt_binary', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constEvalTypeInt_binary);
|
| @@ -5737,6 +6393,18 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constEvalTypeNum_binary);
|
| });
|
| + _ut.test('test_constEval_newInstance_constConstructor', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constEval_newInstance_constConstructor);
|
| + });
|
| + _ut.test('test_constEval_propertyExtraction_methodInstance', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodInstance);
|
| + });
|
| + _ut.test('test_constEval_propertyExtraction_methodStatic_targetInstance', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetInstance);
|
| + });
|
| _ut.test('test_constFormalParameter_fieldFormalParameter', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constFormalParameter_fieldFormalParameter);
|
| @@ -5765,6 +6433,14 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constWithInvalidTypeParameters);
|
| });
|
| + _ut.test('test_constWithInvalidTypeParameters_tooFew', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constWithInvalidTypeParameters_tooFew);
|
| + });
|
| + _ut.test('test_constWithInvalidTypeParameters_tooMany', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constWithInvalidTypeParameters_tooMany);
|
| + });
|
| _ut.test('test_constWithNonConst', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constWithNonConst);
|
| @@ -5777,6 +6453,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constWithNonType);
|
| });
|
| + _ut.test('test_constWithNonType_fromLibrary', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_constWithNonType_fromLibrary);
|
| + });
|
| _ut.test('test_constWithTypeParameters_direct', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_constWithTypeParameters_direct);
|
| @@ -5805,21 +6485,45 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_duplicateConstructorName_unnamed);
|
| });
|
| - _ut.test('test_duplicateDefinition_parameterWithFunctionName_local', () {
|
| + _ut.test('test_duplicateDefinition', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| - runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_local);
|
| + runJUnitTest(__test, __test.test_duplicateDefinition);
|
| });
|
| - _ut.test('test_duplicateDefinition_parameterWithFunctionName_topLevel', () {
|
| + _ut.test('test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| - runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_topLevel);
|
| + runJUnitTest(__test, __test.test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod);
|
| + });
|
| + _ut.test('test_duplicateDefinitionInheritance_instanceMethod_staticMethod', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinitionInheritance_instanceMethod_staticMethod);
|
| + });
|
| + _ut.test('test_duplicateDefinition_acrossLibraries', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_acrossLibraries);
|
| + });
|
| + _ut.test('test_duplicateDefinition_classMembers_fields', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_fields);
|
| + });
|
| + _ut.test('test_duplicateDefinition_classMembers_fields_oneStatic', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_fields_oneStatic);
|
| + });
|
| + _ut.test('test_duplicateDefinition_classMembers_methods', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_methods);
|
| + });
|
| + _ut.test('test_duplicateDefinition_localFields', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_localFields);
|
| });
|
| - _ut.test('test_duplicateMemberError', () {
|
| + _ut.test('test_duplicateDefinition_parameterWithFunctionName_local', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| - runJUnitTest(__test, __test.test_duplicateMemberError);
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_local);
|
| });
|
| - _ut.test('test_duplicateMemberError_classMembers_methods', () {
|
| + _ut.test('test_duplicateDefinition_parameterWithFunctionName_topLevel', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| - runJUnitTest(__test, __test.test_duplicateMemberError_classMembers_methods);
|
| + runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_topLevel);
|
| });
|
| _ut.test('test_duplicateNamedArgument', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| @@ -5977,6 +6681,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_field);
|
| });
|
| + _ut.test('test_implicitThisReferenceInInitializer_field2', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_field2);
|
| + });
|
| _ut.test('test_implicitThisReferenceInInitializer_invocation', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_invocation);
|
| @@ -6033,6 +6741,18 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_static);
|
| });
|
| + _ut.test('test_instanceMemberAccessFromStatic_field', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_field);
|
| + });
|
| + _ut.test('test_instanceMemberAccessFromStatic_getter', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_getter);
|
| + });
|
| + _ut.test('test_instanceMemberAccessFromStatic_method', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_method);
|
| + });
|
| _ut.test('test_invalidConstructorName_notEnclosingClassName', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_invalidConstructorName_notEnclosingClassName);
|
| @@ -6209,6 +6929,26 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_newWithInvalidTypeParameters);
|
| });
|
| + _ut.test('test_newWithInvalidTypeParameters_tooFew', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_newWithInvalidTypeParameters_tooFew);
|
| + });
|
| + _ut.test('test_newWithInvalidTypeParameters_tooMany', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_newWithInvalidTypeParameters_tooMany);
|
| + });
|
| + _ut.test('test_noDefaultSuperConstructorExplicit', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_noDefaultSuperConstructorExplicit);
|
| + });
|
| + _ut.test('test_noDefaultSuperConstructorImplicit_superHasParameters', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superHasParameters);
|
| + });
|
| + _ut.test('test_noDefaultSuperConstructorImplicit_superOnlyNamed', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superOnlyNamed);
|
| + });
|
| _ut.test('test_nonConstCaseExpression', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_nonConstCaseExpression);
|
| @@ -6293,6 +7033,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_nonGenerativeConstructor_implicit);
|
| });
|
| + _ut.test('test_nonGenerativeConstructor_implicit2', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_nonGenerativeConstructor_implicit2);
|
| + });
|
| _ut.test('test_notEnoughRequiredArguments_const', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_notEnoughRequiredArguments_const);
|
| @@ -6513,6 +7257,14 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator_tilde);
|
| });
|
| + _ut.test('test_wrongNumberOfParametersForSetter_function_named', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_named);
|
| + });
|
| + _ut.test('test_wrongNumberOfParametersForSetter_function_optional', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_optional);
|
| + });
|
| _ut.test('test_wrongNumberOfParametersForSetter_function_tooFew', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_tooFew);
|
| @@ -6521,6 +7273,14 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_tooMany);
|
| });
|
| + _ut.test('test_wrongNumberOfParametersForSetter_method_named', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_named);
|
| + });
|
| + _ut.test('test_wrongNumberOfParametersForSetter_method_optional', () {
|
| + final __test = new CompileTimeErrorCodeTest();
|
| + runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_optional);
|
| + });
|
| _ut.test('test_wrongNumberOfParametersForSetter_method_tooFew', () {
|
| final __test = new CompileTimeErrorCodeTest();
|
| runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooFew);
|
| @@ -7203,6 +7963,7 @@ class ElementResolverTest extends EngineTestCase {
|
|
|
| /**
|
| * Create the resolver used by the tests.
|
| + *
|
| * @return the resolver that was created
|
| */
|
| ElementResolver createResolver() {
|
| @@ -7228,6 +7989,7 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the label of the given statement after the resolver has
|
| * resolved the statement.
|
| + *
|
| * @param statement the statement to be resolved
|
| * @param labelElement the label element to be defined in the statement's label scope
|
| * @return the element to which the statement's label was resolved
|
| @@ -7240,6 +8002,7 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the label of the given statement after the resolver has
|
| * resolved the statement.
|
| + *
|
| * @param statement the statement to be resolved
|
| * @param labelElement the label element to be defined in the statement's label scope
|
| * @return the element to which the statement's label was resolved
|
| @@ -7252,9 +8015,10 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the given identifier after the resolver has resolved the
|
| * identifier.
|
| + *
|
| * @param node the expression to be resolved
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| * @return the element to which the expression was resolved
|
| */
|
| Element resolve4(Identifier node, List<Element> definedElements) {
|
| @@ -7265,9 +8029,10 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the given expression after the resolver has resolved the
|
| * expression.
|
| + *
|
| * @param node the expression to be resolved
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| * @return the element to which the expression was resolved
|
| */
|
| Element resolve5(IndexExpression node, List<Element> definedElements) {
|
| @@ -7278,6 +8043,7 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the given identifier after the resolver has resolved the
|
| * identifier.
|
| + *
|
| * @param node the expression to be resolved
|
| * @param enclosingClass the element representing the class enclosing the identifier
|
| * @return the element to which the expression was resolved
|
| @@ -7302,9 +8068,10 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the given identifier after the resolver has resolved the
|
| * identifier.
|
| + *
|
| * @param node the expression to be resolved
|
| * @param definedElements the elements that are to be defined in the scope in which the element is
|
| - * being resolved
|
| + * being resolved
|
| * @return the element to which the expression was resolved
|
| */
|
| void resolveNode(ASTNode node, List<Element> definedElements) {
|
| @@ -7328,6 +8095,7 @@ class ElementResolverTest extends EngineTestCase {
|
| /**
|
| * Return the element associated with the label of the given statement after the resolver has
|
| * resolved the statement.
|
| + *
|
| * @param statement the statement to be resolved
|
| * @param labelElement the label element to be defined in the statement's label scope
|
| * @return the element to which the statement's label was resolved
|
| @@ -7814,6 +8582,18 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| resolve(source);
|
| assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| }
|
| + void test_argumentTypeNotAssignable_annotation_namedConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A.fromInt(int p) {}", "}", "@A.fromInt('0')", "main() {", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| + void test_argumentTypeNotAssignable_annotation_unnamedConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " A(int p) {}", "}", "@A('0')", "main() {", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| void test_argumentTypeNotAssignable_binary() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " operator +(int p) {}", "}", "f(A a) {", " a + '0';", "}"]));
|
| resolve(source);
|
| @@ -8173,13 +8953,13 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| verify([source]);
|
| }
|
| void test_instanceMethodNameCollidesWithSuperclassStatic_setter() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " int i = 0;", " static set n(int x) {i = x;}", "}", "class B extends A {", " void n() {}", "}"]));
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " static set n(int x) {}", "}", "class B extends A {", " void n() {}", "}"]));
|
| resolve(source);
|
| assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| verify([source]);
|
| }
|
| void test_instanceMethodNameCollidesWithSuperclassStatic_setter2() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " int i = 0;", " static set n(int x) {i = x;}", "}", "class B extends A {", "}", "class C extends B {", " void n() {}", "}"]));
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " static set n(int x) {}", "}", "class B extends A {", "}", "class C extends B {", " void n() {}", "}"]));
|
| resolve(source);
|
| assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| verify([source]);
|
| @@ -8286,6 +9066,14 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
|
| verify([source]);
|
| }
|
| + void test_newWithNonType_fromLibrary() {
|
| + Source source1 = addSource2("lib.dart", "");
|
| + Source source2 = addSource2("lib2.dart", EngineTestCase.createSource(["import 'lib.dart' as lib;", "void f() {", " var a = new lib.A();", "}"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
|
| + verify([source1]);
|
| + }
|
| void test_newWithUndefinedConstructor() {
|
| Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", "}", "f() {", " new A.name();", "}"]));
|
| resolve(source);
|
| @@ -8297,24 +9085,6 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
|
| verify([source]);
|
| }
|
| - void test_noDefaultSuperConstructorExplicit() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " A(p);", "}", "class B extends A {", " B() {}", "}"]));
|
| - resolve(source);
|
| - assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
|
| - verify([source]);
|
| - }
|
| - void test_noDefaultSuperConstructorImplicit_superHasParameters() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A {", " A(p);", "}", "class B extends A {", "}"]));
|
| - resolve(source);
|
| - assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| - verify([source]);
|
| - }
|
| - void test_noDefaultSuperConstructorImplicit_superOnlyNamed() {
|
| - Source source = addSource(EngineTestCase.createSource(["class A { A.named() {} }", "class B extends A {}"]));
|
| - resolve(source);
|
| - assertErrors([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
|
| - verify([source]);
|
| - }
|
| void test_nonAbstractClassInheritsAbstractMemberFivePlus() {
|
| Source source = addSource(EngineTestCase.createSource(["abstract class A {", " m();", " n();", " o();", " p();", " q();", "}", "class C extends A {", "}"]));
|
| resolve(source);
|
| @@ -8458,7 +9228,13 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| resolve(source);
|
| assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
|
| }
|
| - void test_redirectToNonClass() {
|
| + void test_redirectToNonClass_notAType() {
|
| + Source source = addSource(EngineTestCase.createSource(["class B {", " int A;", " B() = A;", "}"]));
|
| + resolve(source);
|
| + assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]);
|
| + verify([source]);
|
| + }
|
| + void test_redirectToNonClass_undefinedIdentifier() {
|
| Source source = addSource(EngineTestCase.createSource(["class B {", " B() = A;", "}"]));
|
| resolve(source);
|
| assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]);
|
| @@ -8527,6 +9303,14 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| resolve(source);
|
| assertErrors([StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
|
| }
|
| + void test_undefinedGetter_fromLibrary() {
|
| + Source source1 = addSource2("lib.dart", "");
|
| + Source source2 = addSource2("lib2.dart", EngineTestCase.createSource(["import 'lib.dart' as lib;", "void f() {", " var g = lib.gg;", "}"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
|
| + verify([source1]);
|
| + }
|
| void test_undefinedIdentifier_initializer() {
|
| Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
|
| resolve(source);
|
| @@ -8557,6 +9341,14 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_ambiguousImport_typeArgument_annotation);
|
| });
|
| + _ut.test('test_argumentTypeNotAssignable_annotation_namedConstructor', () {
|
| + final __test = new StaticWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_namedConstructor);
|
| + });
|
| + _ut.test('test_argumentTypeNotAssignable_annotation_unnamedConstructor', () {
|
| + final __test = new StaticWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_unnamedConstructor);
|
| + });
|
| _ut.test('test_argumentTypeNotAssignable_binary', () {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_argumentTypeNotAssignable_binary);
|
| @@ -8869,6 +9661,10 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_newWithNonType);
|
| });
|
| + _ut.test('test_newWithNonType_fromLibrary', () {
|
| + final __test = new StaticWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_newWithNonType_fromLibrary);
|
| + });
|
| _ut.test('test_newWithUndefinedConstructor', () {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_newWithUndefinedConstructor);
|
| @@ -8877,18 +9673,6 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
|
| });
|
| - _ut.test('test_noDefaultSuperConstructorExplicit', () {
|
| - final __test = new StaticWarningCodeTest();
|
| - runJUnitTest(__test, __test.test_noDefaultSuperConstructorExplicit);
|
| - });
|
| - _ut.test('test_noDefaultSuperConstructorImplicit_superHasParameters', () {
|
| - final __test = new StaticWarningCodeTest();
|
| - runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superHasParameters);
|
| - });
|
| - _ut.test('test_noDefaultSuperConstructorImplicit_superOnlyNamed', () {
|
| - final __test = new StaticWarningCodeTest();
|
| - runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superOnlyNamed);
|
| - });
|
| _ut.test('test_nonAbstractClassInheritsAbstractMemberFivePlus', () {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFivePlus);
|
| @@ -8985,9 +9769,13 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_redirectToMissingConstructor_unnamed);
|
| });
|
| - _ut.test('test_redirectToNonClass', () {
|
| + _ut.test('test_redirectToNonClass_notAType', () {
|
| + final __test = new StaticWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_redirectToNonClass_notAType);
|
| + });
|
| + _ut.test('test_redirectToNonClass_undefinedIdentifier', () {
|
| final __test = new StaticWarningCodeTest();
|
| - runJUnitTest(__test, __test.test_redirectToNonClass);
|
| + runJUnitTest(__test, __test.test_redirectToNonClass_undefinedIdentifier);
|
| });
|
| _ut.test('test_returnWithoutValue', () {
|
| final __test = new StaticWarningCodeTest();
|
| @@ -9033,6 +9821,10 @@ class StaticWarningCodeTest extends ResolverTestCase {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_undefinedClass_variableDeclaration);
|
| });
|
| + _ut.test('test_undefinedGetter_fromLibrary', () {
|
| + final __test = new StaticWarningCodeTest();
|
| + runJUnitTest(__test, __test.test_undefinedGetter_fromLibrary);
|
| + });
|
| _ut.test('test_undefinedIdentifier_initializer', () {
|
| final __test = new StaticWarningCodeTest();
|
| runJUnitTest(__test, __test.test_undefinedIdentifier_initializer);
|
| @@ -9155,6 +9947,11 @@ class TestTypeProvider implements TypeProvider {
|
| InterfaceType _stringType;
|
|
|
| /**
|
| + * The type representing the built-in type 'Symbol'.
|
| + */
|
| + InterfaceType _symbolType;
|
| +
|
| + /**
|
| * The type representing the built-in type 'Type'.
|
| */
|
| InterfaceType _typeType;
|
| @@ -9270,6 +10067,12 @@ class TestTypeProvider implements TypeProvider {
|
| }
|
| return _stringType;
|
| }
|
| + InterfaceType get symbolType {
|
| + if (_symbolType == null) {
|
| + _symbolType = ElementFactory.classElement2("Symbol", []).type;
|
| + }
|
| + return _symbolType;
|
| + }
|
| InterfaceType get typeType {
|
| if (_typeType == null) {
|
| _typeType = ElementFactory.classElement2("Type", []).type;
|
| @@ -9306,6 +10109,7 @@ class TestTypeProvider implements TypeProvider {
|
| /**
|
| * Given a class element representing a class with type parameters, propagate those type
|
| * parameters to all of the accessors, methods and constructors defined for the class.
|
| + *
|
| * @param classElement the element representing the class with type parameters
|
| */
|
| void propagateTypeArguments(ClassElementImpl classElement) {
|
| @@ -9332,6 +10136,7 @@ class AnalysisContextFactory {
|
|
|
| /**
|
| * Create an analysis context that has a fake core library already resolved.
|
| + *
|
| * @return the analysis context that was created
|
| */
|
| static AnalysisContextImpl contextWithCore() {
|
| @@ -9535,9 +10340,10 @@ class ResolutionVerifier extends RecursiveASTVisitor<Object> {
|
| * structures that are expected to have been resolved have an element associated with them. Nodes
|
| * in the set of known exceptions are not expected to have been resolved, even if they normally
|
| * would have been expected to have been resolved.
|
| + *
|
| * @param knownExceptions a set containing nodes that are known to not be resolvable and should
|
| - * therefore not cause the test to fail
|
| - */
|
| + * therefore not cause the test to fail
|
| + **/
|
| ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
|
| _jtd_constructor_362_impl(knownExceptions2);
|
| }
|
| @@ -10283,6 +11089,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
| /**
|
| * Return the type associated with the given expression after the static type analyzer has
|
| * computed a type for it.
|
| + *
|
| * @param node the expression with which the type is associated
|
| * @return the type associated with the expression
|
| */
|
| @@ -10291,6 +11098,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
| /**
|
| * Return the type associated with the given expression after the static type analyzer has
|
| * computed a type for it.
|
| + *
|
| * @param node the expression with which the type is associated
|
| * @param thisType the type of 'this'
|
| * @return the type associated with the expression
|
| @@ -10308,6 +11116,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
| /**
|
| * Return the type associated with the given parameter after the static type analyzer has computed
|
| * a type for it.
|
| + *
|
| * @param node the parameter with which the type is associated
|
| * @return the type associated with the parameter
|
| */
|
| @@ -10318,6 +11127,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Assert that the actual type is a function type with the expected characteristics.
|
| + *
|
| * @param expectedReturnType the expected return type of the function
|
| * @param expectedNormalTypes the expected types of the normal parameters
|
| * @param expectedOptionalTypes the expected types of the optional parameters
|
| @@ -10378,6 +11188,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Create the analyzer used by the tests.
|
| + *
|
| * @return the analyzer to be used by the tests
|
| */
|
| StaticTypeAnalyzer createAnalyzer() {
|
| @@ -10402,6 +11213,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Return an integer literal that has been resolved to the correct type.
|
| + *
|
| * @param value the value of the literal
|
| * @return an integer literal that has been resolved to the correct type
|
| */
|
| @@ -10413,8 +11225,10 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Create a function expression that has an element associated with it, where the element has an
|
| - * incomplete type associated with it (just like the one[ElementBuilder#visitFunctionExpression] would have built if we had
|
| + * incomplete type associated with it (just like the one
|
| + * [ElementBuilder#visitFunctionExpression] would have built if we had
|
| * run it).
|
| + *
|
| * @param parameters the parameters to the function
|
| * @param body the body of the function
|
| * @return a resolved function expression
|
| @@ -10435,6 +11249,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Return an integer literal that has been resolved to the correct type.
|
| + *
|
| * @param value the value of the literal
|
| * @return an integer literal that has been resolved to the correct type
|
| */
|
| @@ -10446,6 +11261,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Return a string literal that has been resolved to the correct type.
|
| + *
|
| * @param value the value of the literal
|
| * @return a string literal that has been resolved to the correct type
|
| */
|
| @@ -10457,6 +11273,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Return a simple identifier that has been resolved to a variable element with the given type.
|
| + *
|
| * @param type the type of the variable being represented
|
| * @param variableName the name of the variable
|
| * @return a simple identifier that has been resolved to a variable element with the given type
|
| @@ -10480,6 +11297,7 @@ class StaticTypeAnalyzerTest extends EngineTestCase {
|
|
|
| /**
|
| * Set the type of the given parameter to the given type.
|
| + *
|
| * @param parameter the parameter whose type is to be set
|
| * @param type the new type of the given parameter
|
| */
|
| @@ -10765,7 +11583,7 @@ class EnclosedScopeTest extends ResolverTestCase {
|
| void test_define_duplicate() {
|
| LibraryElement definingLibrary2 = createTestLibrary();
|
| GatheringErrorListener errorListener2 = new GatheringErrorListener();
|
| - Scope rootScope = new Scope_16(definingLibrary2, errorListener2);
|
| + Scope rootScope = new Scope_17(definingLibrary2, errorListener2);
|
| EnclosedScope scope = new EnclosedScope(rootScope);
|
| VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
|
| VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
|
| @@ -10776,7 +11594,7 @@ class EnclosedScopeTest extends ResolverTestCase {
|
| void test_define_normal() {
|
| LibraryElement definingLibrary3 = createTestLibrary();
|
| GatheringErrorListener errorListener3 = new GatheringErrorListener();
|
| - Scope rootScope = new Scope_17(definingLibrary3, errorListener3);
|
| + Scope rootScope = new Scope_18(definingLibrary3, errorListener3);
|
| EnclosedScope outerScope = new EnclosedScope(rootScope);
|
| EnclosedScope innerScope = new EnclosedScope(outerScope);
|
| VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
|
| @@ -10798,18 +11616,18 @@ class EnclosedScopeTest extends ResolverTestCase {
|
| });
|
| }
|
| }
|
| -class Scope_16 extends Scope {
|
| +class Scope_17 extends Scope {
|
| LibraryElement definingLibrary2;
|
| GatheringErrorListener errorListener2;
|
| - Scope_16(this.definingLibrary2, this.errorListener2) : super();
|
| + Scope_17(this.definingLibrary2, this.errorListener2) : super();
|
| LibraryElement get definingLibrary => definingLibrary2;
|
| AnalysisErrorListener get errorListener => errorListener2;
|
| Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
|
| }
|
| -class Scope_17 extends Scope {
|
| +class Scope_18 extends Scope {
|
| LibraryElement definingLibrary3;
|
| GatheringErrorListener errorListener3;
|
| - Scope_17(this.definingLibrary3, this.errorListener3) : super();
|
| + Scope_18(this.definingLibrary3, this.errorListener3) : super();
|
| LibraryElement get definingLibrary => definingLibrary3;
|
| AnalysisErrorListener get errorListener => errorListener3;
|
| Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
|
| @@ -10817,7 +11635,7 @@ class Scope_17 extends Scope {
|
| class LibraryElementBuilderTest extends EngineTestCase {
|
|
|
| /**
|
| - * The source factory used to create [Source sources].
|
| + * The source factory used to create [Source].
|
| */
|
| SourceFactory _sourceFactory;
|
| void setUp() {
|
| @@ -10901,6 +11719,7 @@ class LibraryElementBuilderTest extends EngineTestCase {
|
|
|
| /**
|
| * Add a source file to the content provider. The file path should be absolute.
|
| + *
|
| * @param filePath the path of the file being added
|
| * @param contents the contents to be returned by the content provider for the specified file
|
| * @return the source object representing the added file
|
| @@ -10913,6 +11732,7 @@ class LibraryElementBuilderTest extends EngineTestCase {
|
|
|
| /**
|
| * Ensure that there are elements representing all of the types in the given array of type names.
|
| + *
|
| * @param unit the compilation unit containing the types
|
| * @param typeNames the names of the types that should be found
|
| */
|
| @@ -10937,9 +11757,10 @@ class LibraryElementBuilderTest extends EngineTestCase {
|
|
|
| /**
|
| * Build the element model for the library whose defining compilation unit has the given source.
|
| + *
|
| * @param librarySource the source of the defining compilation unit for the library
|
| * @param expectedErrorCodes the errors that are expected to be found while building the element
|
| - * model
|
| + * model
|
| * @return the element model that was built for the library
|
| * @throws Exception if the element model could not be built
|
| */
|
| @@ -11407,10 +12228,11 @@ class SimpleResolverTest extends ResolverTestCase {
|
| * which the argument expression was resolved is the parameter in the invoked method's list of
|
| * parameters at that index. Arguments that should not be resolved to a parameter because of an
|
| * error can be denoted by including a negative index in the array of indices.
|
| + *
|
| * @param source the source to be resolved
|
| * @param indices the array of indices used to associate arguments with parameters
|
| * @throws Exception if the source could not be resolved or if the structure of the source is not
|
| - * valid
|
| + * valid
|
| */
|
| void validateArgumentResolution(Source source, List<int> indices) {
|
| LibraryElement library = resolve(source);
|
|
|
Chromium Code Reviews
Issue 17932005:
New analyzer_experimental snapshot. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart