| Index: pkg/analyzer/test/generated/static_warning_code_test.dart
|
| diff --git a/pkg/analyzer/test/generated/static_warning_code_test.dart b/pkg/analyzer/test/generated/static_warning_code_test.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..a4807c92325d9f3b5a1369c066181d5e90ed898e
|
| --- /dev/null
|
| +++ b/pkg/analyzer/test/generated/static_warning_code_test.dart
|
| @@ -0,0 +1,2814 @@
|
| +// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
|
| +// for details. All rights reserved. Use of this source code is governed by a
|
| +// BSD-style license that can be found in the LICENSE file.
|
| +
|
| +library engine.static_warning_code_test;
|
| +
|
| +import 'package:analyzer/src/generated/java_junit.dart';
|
| +import 'package:analyzer/src/generated/source_io.dart';
|
| +import 'package:analyzer/src/generated/error.dart';
|
| +import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
|
| +import 'package:unittest/unittest.dart' as _ut;
|
| +import 'resolver_test.dart';
|
| +import 'test_support.dart';
|
| +import '../reflective_tests.dart';
|
| +
|
| +
|
| +class StaticWarningCodeTest extends ResolverTestCase {
|
| + void fail_undefinedGetter() {
|
| + Source source = addSource(EngineTestCase.createSource([]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_GETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void fail_undefinedIdentifier_commentReference() {
|
| + Source source = addSource(EngineTestCase.createSource(["/** [m] xxx [new B.c] */", "class A {", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.UNDEFINED_IDENTIFIER,
|
| + StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void fail_undefinedSetter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", " C.m = 0;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_ambiguousImport_as() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "f(p) {p as N;}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_extends() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "class A extends N {}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + CompileTimeErrorCode.EXTENDS_NON_CLASS]);
|
| + }
|
| +
|
| + void test_ambiguousImport_implements() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "class A implements N {}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
|
| + }
|
| +
|
| + void test_ambiguousImport_inPart() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "library lib;",
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "part 'part.dart';"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + Source partSource = addNamedSource("/part.dart", EngineTestCase.createSource(["part of lib;", "class A extends N {}"]));
|
| + resolve(source);
|
| + assertErrors(partSource, [
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + CompileTimeErrorCode.EXTENDS_NON_CLASS]);
|
| + }
|
| +
|
| + void test_ambiguousImport_instanceCreation() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "library L;",
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "f() {new N();}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_is() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "f(p) {p is N;}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_qualifier() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "g() { N.FOO; }"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_typeAnnotation() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "typedef N FT(N p);",
|
| + "N f(N p) {",
|
| + " N v;",
|
| + " return null;",
|
| + "}",
|
| + "class A {",
|
| + " N m() { return null; }",
|
| + "}",
|
| + "class B<T extends N> {}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT,
|
| + StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_typeArgument_annotation() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "class A<T> {}",
|
| + "A<N> f() { return null; }"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_typeArgument_instanceCreation() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "class A<T> {}",
|
| + "f() {new A<N>();}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_varRead() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "f() { g(v); }",
|
| + "g(p) {}"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_ambiguousImport_varWrite() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';",
|
| + "f() { v = 0; }"]));
|
| + addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_ambiguousClassName() {
|
| + // See dartbug.com/19624
|
| + Source source = addNamedSource("/lib1.dart", EngineTestCase.createSource([
|
| + "library lib1;",
|
| + "import 'lib2.dart';",
|
| + "class _A {}",
|
| + "f() {",
|
| + " g((_A a) {});",
|
| + "}"]));
|
| + addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class _A {}", "g(h(_A a)) {}"]));
|
| + resolve(source);
|
| + // The name _A is private to the library it's defined in, so this is a type mismatch.
|
| + // Furthermore, the error message should mention both _A and the filenames
|
| + // so the user can figure out what's going on.
|
| + List<AnalysisError> errors = analysisContext2.computeErrors(source);
|
| + EngineTestCase.assertLength(1, errors);
|
| + AnalysisError error = errors[0];
|
| + JUnitTestCase.assertEquals(error.errorCode, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
|
| + String message = error.message;
|
| + JUnitTestCase.assertTrue(message.indexOf("_A") != -1);
|
| + JUnitTestCase.assertTrue(message.indexOf("lib1.dart") != -1);
|
| + JUnitTestCase.assertTrue(message.indexOf("lib2.dart") != -1);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_annotation_namedConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " const A.fromInt(int p);",
|
| + "}",
|
| + "@A.fromInt('0')",
|
| + "main() {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_annotation_unnamedConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " const A(int p);",
|
| + "}",
|
| + "@A('0')",
|
| + "main() {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [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);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_cascadeSecond() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "// filler filler filler filler filler filler filler filler filler filler",
|
| + "class A {",
|
| + " B ma() { return new B(); }",
|
| + "}",
|
| + "class B {",
|
| + " mb(String p) {}",
|
| + "}",
|
| + "",
|
| + "main() {",
|
| + " A a = new A();",
|
| + " a.. ma().mb(0);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_const() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " const A(String p);",
|
| + "}",
|
| + "main() {",
|
| + " const A(42);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE,
|
| + CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_const_super() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " const A(String p);",
|
| + "}",
|
| + "class B extends A {",
|
| + " const B() : super(42);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_functionExpressionInvocation_required() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " (int x) {} ('');", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_index() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " operator [](int index) {}",
|
| + "}",
|
| + "f(A a) {",
|
| + " a['0'];",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_callParameter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " call(int p) {}",
|
| + "}",
|
| + "f(A a) {",
|
| + " a('0');",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_callVariable() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " call(int p) {}",
|
| + "}",
|
| + "main() {",
|
| + " A a = new A();",
|
| + " a('0');",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_functionParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["a(b(int p)) {", " b('0');", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_functionParameter_generic() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A<K, V> {",
|
| + " m(f(K k), V v) {",
|
| + " f(v);",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_functionTypes_optional() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "void acceptFunNumOptBool(void funNumOptBool([bool b])) {}",
|
| + "void funNumBool(bool b) {}",
|
| + "main() {",
|
| + " acceptFunNumOptBool(funNumBool);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_generic() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A<T> {",
|
| + " m(T t) {}",
|
| + "}",
|
| + "f(A<String> a) {",
|
| + " a.m(1);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_named() {
|
| + Source source = addSource(EngineTestCase.createSource(["f({String p}) {}", "main() {", " f(p: 42);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_optional() {
|
| + Source source = addSource(EngineTestCase.createSource(["f([String p]) {}", "main() {", " f(42);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_required() {
|
| + Source source = addSource(EngineTestCase.createSource(["f(String p) {}", "main() {", " f(42);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_typedef_generic() {
|
| + Source source = addSource(EngineTestCase.createSource(["typedef A<T>(T p);", "f(A<int> a) {", " a('1');", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_typedef_local() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "typedef A(int p);",
|
| + "A getA() => null;",
|
| + "main() {",
|
| + " A a = getA();",
|
| + " a('1');",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_invocation_typedef_parameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["typedef A(int p);", "f(A a) {", " a('1');", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_new_generic() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A<T> {",
|
| + " A(T p) {}",
|
| + "}",
|
| + "main() {",
|
| + " new A<String>(42);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_new_optional() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " A([String p]) {}",
|
| + "}",
|
| + "main() {",
|
| + " new A(42);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_argumentTypeNotAssignable_new_required() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " A(String p) {}",
|
| + "}",
|
| + "main() {",
|
| + " new A(42);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToConst_instanceVariable() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static const v = 0;",
|
| + "}",
|
| + "f() {",
|
| + " A.v = 1;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToConst_instanceVariable_plusEq() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static const v = 0;",
|
| + "}",
|
| + "f() {",
|
| + " A.v += 1;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToConst_localVariable() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " const x = 0;", " x = 1;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToConst_localVariable_plusEq() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " const x = 0;", " x += 1;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_instanceVariable() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " final v = 0;",
|
| + "}",
|
| + "f() {",
|
| + " A a = new A();",
|
| + " a.v = 1;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_instanceVariable_plusEq() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " final v = 0;",
|
| + "}",
|
| + "f() {",
|
| + " A a = new A();",
|
| + " a.v += 1;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_localVariable() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x = 1;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_localVariable_plusEq() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x += 1;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_postfixMinusMinus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x--;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_postfixPlusPlus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x++;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_prefixMinusMinus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " --x;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_prefixPlusPlus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " ++x;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_suffixMinusMinus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x--;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_suffixPlusPlus() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final x = 0;", " x++;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinal_topLevelVariable() {
|
| + Source source = addSource(EngineTestCase.createSource(["final x = 0;", "f() { x = 1; }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinalNoSetter_prefixedIdentifier() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int get x => 0;",
|
| + "}",
|
| + "main() {",
|
| + " A a = new A();",
|
| + " a.x = 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFinalNoSetter_propertyAccess() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int get x => 0;",
|
| + "}",
|
| + "class B {",
|
| + " static A a;",
|
| + "}",
|
| + "main() {",
|
| + " B.a.x = 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToFunction() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", " f = null;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FUNCTION]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_assignmentToMethod() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m() {}",
|
| + "}",
|
| + "f(A a) {",
|
| + " a.m = () {};",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_METHOD]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_caseBlockNotTerminated() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "f(int p) {",
|
| + " switch (p) {",
|
| + " case 0:",
|
| + " f(p);",
|
| + " case 1:",
|
| + " break;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_castToNonType() {
|
| + Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(String s) { var x = s as A; }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CAST_TO_NON_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_concreteClassWithAbstractMember() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m();", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingDartImport() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib.dart';",
|
| + "import 'dart:async';",
|
| + "Future f = null;",
|
| + "Stream s;"]));
|
| + addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class Future {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_DART_IMPORT]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static set v(x) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " var v;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_getter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static get v => 0;",
|
| + "}",
|
| + "class B extends A {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_method() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static v() {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_setter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static set v(x) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declGetter_indirect() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static int v;",
|
| + "}",
|
| + "class B extends A {}",
|
| + "class C extends B {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_declGetter_mixin() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class M {",
|
| + " static int v;",
|
| + "}",
|
| + "class B extends Object with M {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceGetterAndSuperclassMember_direct_field() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static int v;",
|
| + "}",
|
| + "class B extends A {",
|
| + " get v => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceMethodSetter_sameClass() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " set foo(a) {}", " foo() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceMethodSetter_setterInInterface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " set foo(a);",
|
| + "}",
|
| + "abstract class B implements A {",
|
| + " foo() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceMethodSetter_setterInSuper() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " set foo(a) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " foo() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceMethodSetter2() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " foo() {}", " set foo(a) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingInstanceSetterAndSuperclassMember() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static int v;",
|
| + "}",
|
| + "class B extends A {",
|
| + " set v(x) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingStaticGetterAndInstanceSetter_mixin() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " set x(int p) {}",
|
| + "}",
|
| + "class B extends Object with A {",
|
| + " static get x => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingStaticGetterAndInstanceSetter_superClass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " set x(int p) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " static get x => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static get x => 0;",
|
| + " set x(int p) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingStaticSetterAndInstanceMember_thisClass_getter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " get x => 0;",
|
| + " static set x(int p) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_conflictingStaticSetterAndInstanceMember_thisClass_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " x() {}", " static set x(int p) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_constWithAbstractClass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " const A();",
|
| + "}",
|
| + "void f() {",
|
| + " A a = const A();",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_equalKeysInMap() {
|
| + Source source = addSource(EngineTestCase.createSource(["var m = {'a' : 0, 'b' : 1, 'a' : 2};"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.EQUAL_KEYS_IN_MAP]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_equalKeysInMap_withEqualTypeParams() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A<T> {",
|
| + " const A();",
|
| + "}",
|
| + "var m = {const A<int>(): 0, const A<int>(): 1};"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.EQUAL_KEYS_IN_MAP]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_equalKeysInMap_withUnequalTypeParams() {
|
| + // No error should be produced because A<int> and A<num> are different types.
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A<T> {",
|
| + " const A();",
|
| + "}",
|
| + "var m = {const A<int>(): 0, const A<num>(): 1};"]));
|
| + resolve(source);
|
| + assertNoErrors(source);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_exportDuplicatedLibraryName() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "library test;",
|
| + "export 'lib1.dart';",
|
| + "export 'lib2.dart';"]));
|
| + addNamedSource("/lib1.dart", "library lib;");
|
| + addNamedSource("/lib2.dart", "library lib;");
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_extraPositionalArguments() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", " f(0, 1, '2');", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_extraPositionalArguments_functionExpression() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " (int x) {} (0, 1);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_fieldInitializedInInitializerAndDeclaration_final() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " final int x = 0;",
|
| + " A() : x = 1 {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_fieldInitializerNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " A() : x = '';", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_fieldInitializingFormalNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " A(String this.x) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + /**
|
| + * This test doesn't test the FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR code, but tests the
|
| + * FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION code instead. It is provided here to show
|
| + * coverage over all of the permutations of initializers in constructor declarations.
|
| + *
|
| + * Note: FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION covers a subset of
|
| + * FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, since it more specific, we use it instead of
|
| + * the broader code
|
| + */
|
| + void test_finalInitializedInDeclarationAndConstructor_initializers() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " final x = 0;", " A() : x = 0 {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " final x = 0;", " A(this.x) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalNotInitialized_inConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " final int x;", " A() {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalNotInitialized_instanceField_final() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " final F;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalNotInitialized_instanceField_final_static() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " static final F;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalNotInitialized_library_final() {
|
| + Source source = addSource(EngineTestCase.createSource(["final F;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_finalNotInitialized_local_final() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " final int x;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FINAL_NOT_INITIALIZED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_functionWithoutCall_direct() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A implements Function {", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FUNCTION_WITHOUT_CALL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_functionWithoutCall_indirect_extends() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A implements Function {",
|
| + "}",
|
| + "class B extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FUNCTION_WITHOUT_CALL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_functionWithoutCall_indirect_implements() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A implements Function {",
|
| + "}",
|
| + "class B implements A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.FUNCTION_WITHOUT_CALL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_importDuplicatedLibraryName() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "library test;",
|
| + "import 'lib1.dart';",
|
| + "import 'lib2.dart';"]));
|
| + addNamedSource("/lib1.dart", "library lib;");
|
| + addNamedSource("/lib2.dart", "library lib;");
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME,
|
| + HintCode.UNUSED_IMPORT,
|
| + HintCode.UNUSED_IMPORT]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_importOfNonLibrary() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["part of lib;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library lib;",
|
| + "import 'lib1.dart' deferred as p;",
|
| + "var a = new p.A();"])], <ErrorCode> [
|
| + CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY,
|
| + ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.IMPORT_OF_NON_LIBRARY]);
|
| + }
|
| +
|
| + void test_inconsistentMethodInheritanceGetterAndMethod() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " int x();",
|
| + "}",
|
| + "abstract class B {",
|
| + " int get x;",
|
| + "}",
|
| + "class C implements A, B {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_field() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static var n;",
|
| + "}",
|
| + "class B extends A {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_field2() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static var n;",
|
| + "}",
|
| + "class B extends A {",
|
| + "}",
|
| + "class C extends B {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_getter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static get n {return 0;}",
|
| + "}",
|
| + "class B extends A {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_getter2() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static get n {return 0;}",
|
| + "}",
|
| + "class B extends A {",
|
| + "}",
|
| + "class C extends B {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_method() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static n () {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_method2() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static n () {}",
|
| + "}",
|
| + "class B extends A {",
|
| + "}",
|
| + "class C extends B {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_setter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " static set n(int x) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " void n() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_instanceMethodNameCollidesWithSuperclassStatic_setter2() {
|
| + 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(source, [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidGetterOverrideReturnType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int get g { return 0; }",
|
| + "}",
|
| + "class B extends A {",
|
| + " String get g { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidGetterOverrideReturnType_implicit() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " String f;",
|
| + "}",
|
| + "class B extends A {",
|
| + " int f;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
|
| + StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidGetterOverrideReturnType_twoInterfaces() {
|
| + // test from language/override_inheritance_field_test_11.dart
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " int get getter => null;",
|
| + "}",
|
| + "abstract class J {",
|
| + " num get getter => null;",
|
| + "}",
|
| + "abstract class A implements I, J {}",
|
| + "class B extends A {",
|
| + " String get getter => null;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidGetterOverrideReturnType_twoInterfaces_conflicting() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I<U> {",
|
| + " U get g => null;",
|
| + "}",
|
| + "abstract class J<V> {",
|
| + " V get g => null;",
|
| + "}",
|
| + "class B implements I<int>, J<String> {",
|
| + " double get g => null;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNamedParamType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m({int a}) {}",
|
| + "}",
|
| + "class B implements A {",
|
| + " m({String a}) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNormalParamType_interface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m(int a) {}",
|
| + "}",
|
| + "class B implements A {",
|
| + " m(String a) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNormalParamType_superclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m(int a) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m(String a) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNormalParamType_superclass_interface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I<U> {",
|
| + " m(U u) => null;",
|
| + "}",
|
| + "abstract class J<V> {",
|
| + " m(V v) => null;",
|
| + "}",
|
| + "class B extends I<int> implements J<String> {",
|
| + " m(double d) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNormalParamType_twoInterfaces() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " m(int n);",
|
| + "}",
|
| + "abstract class J {",
|
| + " m(num n);",
|
| + "}",
|
| + "abstract class A implements I, J {}",
|
| + "class B extends A {",
|
| + " m(String n) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideNormalParamType_twoInterfaces_conflicting() {
|
| + // language/override_inheritance_generic_test/08
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I<U> {",
|
| + " m(U u) => null;",
|
| + "}",
|
| + "abstract class J<V> {",
|
| + " m(V v) => null;",
|
| + "}",
|
| + "class B implements I<int>, J<String> {",
|
| + " m(double d) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideOptionalParamType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m([int a]) {}",
|
| + "}",
|
| + "class B implements A {",
|
| + " m([String a]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideOptionalParamType_twoInterfaces() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " m([int n]);",
|
| + "}",
|
| + "abstract class J {",
|
| + " m([num n]);",
|
| + "}",
|
| + "abstract class A implements I, J {}",
|
| + "class B extends A {",
|
| + " m([String n]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_interface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int m() { return 0; }",
|
| + "}",
|
| + "class B implements A {",
|
| + " String m() { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_interface_grandparent() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " int m();",
|
| + "}",
|
| + "abstract class B implements A {",
|
| + "}",
|
| + "class C implements B {",
|
| + " String m() { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_mixin() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int m() { return 0; }",
|
| + "}",
|
| + "class B extends Object with A {",
|
| + " String m() { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_superclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int m() { return 0; }",
|
| + "}",
|
| + "class B extends A {",
|
| + " String m() { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_superclass_grandparent() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int m() { return 0; }",
|
| + "}",
|
| + "class B extends A {",
|
| + "}",
|
| + "class C extends B {",
|
| + " String m() { return 'a'; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_twoInterfaces() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " int m();",
|
| + "}",
|
| + "abstract class J {",
|
| + " num m();",
|
| + "}",
|
| + "abstract class A implements I, J {}",
|
| + "class B extends A {",
|
| + " String m() => '';",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidMethodOverrideReturnType_void() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int m() { return 0; }",
|
| + "}",
|
| + "class B extends A {",
|
| + " void m() {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverrideDifferentDefaultValues_named() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m({int p : 0}) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m({int p : 1}) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverrideDifferentDefaultValues_positional() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m([int p = 0]) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m([int p = 1]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverrideNamed_fewerNamedParameters() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m({a, b}) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m({a}) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverrideNamed_missingNamedParameter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m({a, b}) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m({a, c}) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverridePositional_optional() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m([a, b]) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m([a]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverridePositional_optionalAndRequired() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m(a, b, [c, d]) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m(a, b, [c]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverridePositional_optionalAndRequired2() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m(a, b, [c, d]) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m(a, [c, d]) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidOverrideRequired() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " m(a) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " m(a, b) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_REQUIRED]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidSetterOverrideNormalParamType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " void set s(int v) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " void set s(String v) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidSetterOverrideNormalParamType_superclass_interface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " set setter14(int _) => null;",
|
| + "}",
|
| + "abstract class J {",
|
| + " set setter14(num _) => null;",
|
| + "}",
|
| + "abstract class A extends I implements J {}",
|
| + "class B extends A {",
|
| + " set setter14(String _) => null;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidSetterOverrideNormalParamType_twoInterfaces() {
|
| + // test from language/override_inheritance_field_test_34.dart
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I {",
|
| + " set setter14(int _) => null;",
|
| + "}",
|
| + "abstract class J {",
|
| + " set setter14(num _) => null;",
|
| + "}",
|
| + "abstract class A implements I, J {}",
|
| + "class B extends A {",
|
| + " set setter14(String _) => null;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_invalidSetterOverrideNormalParamType_twoInterfaces_conflicting() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class I<U> {",
|
| + " set s(U u) {}",
|
| + "}",
|
| + "abstract class J<V> {",
|
| + " set s(V v) {}",
|
| + "}",
|
| + "class B implements I<int>, J<String> {",
|
| + " set s(double d) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_listElementTypeNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource(["var v = <String> [42];"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mapKeyTypeNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource(["var v = <String, int > {1 : 2};"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mapValueTypeNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource(["var v = <String, String> {'a' : 2};"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mismatchedAccessorTypes_class() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int get g { return 0; }",
|
| + " set g(String v) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mismatchedAccessorTypes_getterAndSuperSetter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int get g { return 0; }",
|
| + "}",
|
| + "class B extends A {",
|
| + " set g(String v) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mismatchedAccessorTypes_setterAndSuperGetter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " set g(int v) {}",
|
| + "}",
|
| + "class B extends A {",
|
| + " String get g { return ''; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mismatchedAccessorTypes_topLevel() {
|
| + Source source = addSource(EngineTestCase.createSource(["int get g { return 0; }", "set g(String v) {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mixedReturnTypes_localFunction() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class C {",
|
| + " m(int x) {",
|
| + " return (int y) {",
|
| + " if (y < 0) {",
|
| + " return;",
|
| + " }",
|
| + " return 0;",
|
| + " };",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.MIXED_RETURN_TYPES,
|
| + StaticWarningCode.MIXED_RETURN_TYPES]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mixedReturnTypes_method() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class C {",
|
| + " m(int x) {",
|
| + " if (x < 0) {",
|
| + " return;",
|
| + " }",
|
| + " return 0;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.MIXED_RETURN_TYPES,
|
| + StaticWarningCode.MIXED_RETURN_TYPES]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_mixedReturnTypes_topLevelFunction() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "f(int x) {",
|
| + " if (x < 0) {",
|
| + " return;",
|
| + " }",
|
| + " return 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [
|
| + StaticWarningCode.MIXED_RETURN_TYPES,
|
| + StaticWarningCode.MIXED_RETURN_TYPES]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_newWithAbstractClass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {}",
|
| + "void f() {",
|
| + " A a = new A();",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_newWithInvalidTypeParameters() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { return new A<A>(); }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.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(source, [StaticWarningCode.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(source, [StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_newWithNonType() {
|
| + Source source = addSource(EngineTestCase.createSource(["var A = 0;", "void f() {", " var a = new A();", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NEW_WITH_NON_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_newWithNonType_fromLibrary() {
|
| + Source source1 = addNamedSource("lib.dart", "class B {}");
|
| + Source source2 = addNamedSource("lib2.dart", EngineTestCase.createSource([
|
| + "import 'lib.dart' as lib;",
|
| + "void f() {",
|
| + " var a = new lib.A();",
|
| + "}",
|
| + "lib.B b;"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors(source2, [StaticWarningCode.NEW_WITH_NON_TYPE]);
|
| + verify([source1]);
|
| + }
|
| +
|
| + void test_newWithUndefinedConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " A() {}",
|
| + "}",
|
| + "f() {",
|
| + " new A.name();",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
|
| + // no verify(), 'name' is not resolved
|
| + }
|
| +
|
| + void test_newWithUndefinedConstructorDefault() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " A.name() {}",
|
| + "}",
|
| + "f() {",
|
| + " new A();",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberFivePlus() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " m();",
|
| + " n();",
|
| + " o();",
|
| + " p();",
|
| + " q();",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberFour() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " m();",
|
| + " n();",
|
| + " o();",
|
| + " p();",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
|
| + // 15979
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class M {}",
|
| + "abstract class A {}",
|
| + "abstract class I {",
|
| + " m();",
|
| + "}",
|
| + "class B = A with M implements I;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin() {
|
| + // 15979
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class M {",
|
| + " m();",
|
| + "}",
|
| + "abstract class A {}",
|
| + "class B = A with M;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
|
| + // 15979
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class M {}",
|
| + "abstract class A {",
|
| + " m();",
|
| + "}",
|
| + "class B = A with M;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
|
| + // 15028
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class C {",
|
| + " foo(int x) => x;",
|
| + "}",
|
| + "abstract class D {",
|
| + " foo(x, [y]);",
|
| + "}",
|
| + "class E extends C implements D {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " int get g {return 1;}",
|
| + "}",
|
| + "class C implements I {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " int get g;",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " m(p) {}",
|
| + "}",
|
| + "class C implements I {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " m(p);",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
|
| + // 7640
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " int x(int a);",
|
| + "}",
|
| + "abstract class B {",
|
| + " int x(int a, [int b]);",
|
| + "}",
|
| + "class C implements A, B {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_getter() {
|
| + // 15001
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A { get g1; get g2; }",
|
| + "abstract class B implements A { get g1 => 1; }",
|
| + "class C extends Object with B {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_method() {
|
| + // 15001
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A { m1(); m2(); }",
|
| + "abstract class B implements A { m1() => 1; }",
|
| + "class C extends Object with B {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_setter() {
|
| + // 15001
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A { set s1(v); set s2(v); }",
|
| + "abstract class B implements A { set s1(v) {} }",
|
| + "class C extends Object with B {}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter() {
|
| + // test from language/override_inheritance_abstract_test_14.dart
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " set field(_);",
|
| + "}",
|
| + "abstract class I {",
|
| + " var field;",
|
| + "}",
|
| + "class B extends A implements I {",
|
| + " get field => 0;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " set s(int i) {}",
|
| + "}",
|
| + "class C implements I {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " set s(int i);",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() {
|
| + // bug 11154
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " get a => 'a';",
|
| + "}",
|
| + "abstract class B implements A {",
|
| + " get b => 'b';",
|
| + "}",
|
| + "class C extends B {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter() {
|
| + // 16133
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " var v;",
|
| + "}",
|
| + "class C implements I {",
|
| + " set v(_) {}",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter() {
|
| + // 16133
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " var v;",
|
| + "}",
|
| + "class C implements I {",
|
| + " get v => 1;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberThree() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " m();",
|
| + " n();",
|
| + " o();",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberTwo() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "abstract class A {",
|
| + " m();",
|
| + " n();",
|
| + "}",
|
| + "class C extends A {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth() {
|
| + // 16133
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class I {",
|
| + " var v;",
|
| + "}",
|
| + "class C implements I {",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonTypeInCatchClause_noElement() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {", " try {", " } on T catch (e) {", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonTypeInCatchClause_notType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "var T = 0;",
|
| + "f() {",
|
| + " try {",
|
| + " } on T catch (e) {",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonVoidReturnForOperator() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int operator []=(a, b) { return a; }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonVoidReturnForSetter_function() {
|
| + Source source = addSource(EngineTestCase.createSource(["int set x(int v) {", " return 42;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_nonVoidReturnForSetter_method() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " int set x(int v) {",
|
| + " return 42;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_notAType() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", " f v = null;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NOT_A_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_notEnoughRequiredArguments() {
|
| + Source source = addSource(EngineTestCase.createSource(["f(int a, String b) {}", "main() {", " f();", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_notEnoughRequiredArguments_functionExpression() {
|
| + Source source = addSource(EngineTestCase.createSource(["main() {", " (int x) {} ();", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_notEnoughRequiredArguments_getterReturningFunction() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "typedef Getter(self);",
|
| + "Getter getter = (x) => x;",
|
| + "main() {",
|
| + " getter();",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_partOfDifferentLibrary() {
|
| + Source source = addSource(EngineTestCase.createSource(["library lib;", "part 'part.dart';"]));
|
| + addNamedSource("/part.dart", EngineTestCase.createSource(["part of lub;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.PART_OF_DIFFERENT_LIBRARY]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_redirectToInvalidFunctionType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A implements B {",
|
| + " A(int p) {}",
|
| + "}",
|
| + "class B {",
|
| + " factory B() = A;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_redirectToInvalidReturnType() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " A() {}",
|
| + "}",
|
| + "class B {",
|
| + " factory B() = A;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_redirectToMissingConstructor_named() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A implements B{",
|
| + " A() {}",
|
| + "}",
|
| + "class B {",
|
| + " factory B() = A.name;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
|
| + }
|
| +
|
| + void test_redirectToMissingConstructor_unnamed() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A implements B{",
|
| + " A.name() {}",
|
| + "}",
|
| + "class B {",
|
| + " factory B() = A;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
|
| + }
|
| +
|
| + void test_redirectToNonClass_notAType() {
|
| + Source source = addSource(EngineTestCase.createSource(["class B {", " int A;", " factory B() = A;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_NON_CLASS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_redirectToNonClass_undefinedIdentifier() {
|
| + Source source = addSource(EngineTestCase.createSource(["class B {", " factory B() = A;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.REDIRECT_TO_NON_CLASS]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_returnWithoutValue_factoryConstructor() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A { factory A() { return; } }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_returnWithoutValue_function() {
|
| + Source source = addSource(EngineTestCase.createSource(["int f() { return; }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_returnWithoutValue_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A { int m() { return; } }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_returnWithoutValue_mixedReturnTypes_function() {
|
| + // Tests that only the RETURN_WITHOUT_VALUE warning is created, and no MIXED_RETURN_TYPES are
|
| + // created.
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "int f(int x) {",
|
| + " if (x < 0) {",
|
| + " return 1;",
|
| + " }",
|
| + " return;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.RETURN_WITHOUT_VALUE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_staticAccessToInstanceMember_method_invocation() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", "}", "main() {", " A.m();", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_staticAccessToInstanceMember_method_reference() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", "}", "main() {", " A.m;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_staticAccessToInstanceMember_propertyAccess_field() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A {", " var f;", "}", "main() {", " A.f;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_staticAccessToInstanceMember_propertyAccess_getter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " get f => 42;",
|
| + "}",
|
| + "main() {",
|
| + " A.f;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_staticAccessToInstanceMember_propertyAccess_setter() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class A {",
|
| + " set f(x) {}",
|
| + "}",
|
| + "main() {",
|
| + " A.f = 42;",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_switchExpressionNotAssignable() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "f(int p) {",
|
| + " switch (p) {",
|
| + " case 'a': break;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_asExpression() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "f(var v) {",
|
| + " v as a.A;",
|
| + "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_catchClause() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "f(var v) {",
|
| + " try {",
|
| + " } on a.A {",
|
| + " }",
|
| + "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_fieldFormalParameter() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "class C {",
|
| + " var v;",
|
| + " C(a.A this.v);",
|
| + "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_functionDeclaration_returnType() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "a.A f() { return null; }"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "f(a.A g()) {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_isExpression() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "f(var v) {",
|
| + " bool b = v is a.A;",
|
| + "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_methodDeclaration_returnType() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "class C {",
|
| + " a.A m() { return null; }",
|
| + "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_simpleFormalParameter() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "f(a.A v) {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_typeArgumentList() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "class C<E> {}",
|
| + "C<a.A> c;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_typeArgumentList2() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "class C<E, F> {}",
|
| + "C<a.A, a.A> c;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [
|
| + StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS,
|
| + StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_typeParameter_bound() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "class C<E extends a.A> {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeAnnotationDeferredClass_variableDeclarationList() {
|
| + resolveWithAndWithoutExperimental(<String> [
|
| + EngineTestCase.createSource(["library lib1;", "class A {}"]),
|
| + EngineTestCase.createSource([
|
| + "library root;",
|
| + "import 'lib1.dart' deferred as a;",
|
| + "a.A v;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_field() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static K k;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_getter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static K get k => null;", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_methodBodyReference() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static m() {", " K k;", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_methodParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static m(K k) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_methodReturn() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static K m() { return null; }", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typeParameterReferencedByStatic_setter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class A<K> {", " static set s(K k) {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_typePromotion_functionType_arg_InterToDyn() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "typedef FuncDyn(x);",
|
| + "typedef FuncA(A a);",
|
| + "class A {}",
|
| + "class B {}",
|
| + "main(FuncA f) {",
|
| + " if (f is FuncDyn) {",
|
| + " f(new B());",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
|
| + }
|
| +
|
| + void test_typeTestNonType() {
|
| + Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(var p) {", " if (p is A) {", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.TYPE_TEST_NON_TYPE]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_undefinedClass_instanceCreation() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() { new C(); }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
|
| + }
|
| +
|
| + void test_undefinedClass_variableDeclaration() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() { C c; }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
|
| + }
|
| +
|
| + void test_undefinedClassBoolean_variableDeclaration() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() { boolean v; }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
|
| + }
|
| +
|
| + void test_undefinedGetter_fromLibrary() {
|
| + Source source1 = addNamedSource("lib.dart", "");
|
| + Source source2 = addNamedSource("lib2.dart", EngineTestCase.createSource([
|
| + "import 'lib.dart' as lib;",
|
| + "void f() {",
|
| + " var g = lib.gg;",
|
| + "}"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors(source2, [StaticWarningCode.UNDEFINED_GETTER]);
|
| + verify([source1]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_for() {
|
| + Source source = addSource(EngineTestCase.createSource(["f(var l) {", " for (e in l) {", " }", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_function() {
|
| + Source source = addSource(EngineTestCase.createSource(["int a() => b;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_function_prefix() {
|
| + addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
|
| + Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "int a() => b;", "b.C c;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + verify([source]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_initializer() {
|
| + Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_initializer_prefix() {
|
| + addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
|
| + Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "var a = b;", "b.C c;"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_methodInvocation() {
|
| + Source source = addSource(EngineTestCase.createSource(["f() { C.m(); }"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_private_getter() {
|
| + addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", " var _foo;", "}"]));
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib.dart';",
|
| + "class B extends A {",
|
| + " test() {",
|
| + " var v = _foo;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedIdentifier_private_setter() {
|
| + addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", " var _foo;", "}"]));
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "import 'lib.dart';",
|
| + "class B extends A {",
|
| + " test() {",
|
| + " _foo = 42;",
|
| + " }",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
|
| + }
|
| +
|
| + void test_undefinedNamedParameter() {
|
| + Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", " f(c: 1);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
|
| + // no verify(), 'c' is not resolved
|
| + }
|
| +
|
| + void test_undefinedSetter() {
|
| + Source source1 = addNamedSource("lib.dart", "");
|
| + Source source2 = addNamedSource("lib2.dart", EngineTestCase.createSource([
|
| + "import 'lib.dart' as lib;",
|
| + "void f() {",
|
| + " lib.gg = null;",
|
| + "}"]));
|
| + resolve(source1);
|
| + resolve(source2);
|
| + assertErrors(source2, [StaticWarningCode.UNDEFINED_SETTER]);
|
| + }
|
| +
|
| + void test_undefinedStaticMethodOrGetter_getter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", " f(C.m);", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
|
| + }
|
| +
|
| + void test_undefinedStaticMethodOrGetter_getter_inSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class S {",
|
| + " static int get g => 0;",
|
| + "}",
|
| + "class C extends S {}",
|
| + "f(var p) {",
|
| + " f(C.g);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
|
| + }
|
| +
|
| + void test_undefinedStaticMethodOrGetter_method() {
|
| + Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", " f(C.m());", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
|
| + }
|
| +
|
| + void test_undefinedStaticMethodOrGetter_method_inSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class S {",
|
| + " static m() {}",
|
| + "}",
|
| + "class C extends S {}",
|
| + "f(var p) {",
|
| + " f(C.m());",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
|
| + }
|
| +
|
| + void test_undefinedStaticMethodOrGetter_setter_inSuperclass() {
|
| + Source source = addSource(EngineTestCase.createSource([
|
| + "class S {",
|
| + " static set s(int i) {}",
|
| + "}",
|
| + "class C extends S {}",
|
| + "f(var p) {",
|
| + " f(C.s = 1);",
|
| + "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
|
| + }
|
| +
|
| + void test_voidReturnForGetter() {
|
| + Source source = addSource(EngineTestCase.createSource(["class S {", " void get value {}", "}"]));
|
| + resolve(source);
|
| + assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
|
| + }
|
| +}
|
| +
|
| +main() {
|
| + _ut.groupSep = ' | ';
|
| + runReflectiveTests(StaticWarningCodeTest);
|
| +}
|
|
|
Chromium Code Reviews
Issue 656543003:
Split up large resolver_test.dart file. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart