| // 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. |
| |
| import 'package:analyzer/dart/analysis/results.dart'; |
| import 'package:analyzer/dart/ast/ast.dart'; |
| import 'package:analyzer/src/error/codes.dart'; |
| import 'package:test/test.dart'; |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; |
| |
| import '../src/dart/resolution/driver_resolution.dart'; |
| import 'test_support.dart'; |
| |
| main() { |
| defineReflectiveSuite(() { |
| defineReflectiveTests(StaticWarningCodeTest); |
| }); |
| } |
| |
| @reflectiveTest |
| class StaticWarningCodeTest extends DriverResolutionTest { |
| test_ambiguousImport_as() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| f(p) {p as N;}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 51, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_dart() async { |
| await assertErrorsInCode(''' |
| import 'dart:async'; |
| import 'dart:async2'; |
| |
| Future v; |
| ''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 44, 6), |
| ]); |
| } |
| |
| test_ambiguousImport_extends() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| class A extends N {}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 56, 1), |
| error(CompileTimeErrorCode.EXTENDS_NON_CLASS, 56, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_implements() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| class A implements N {}''', [ |
| error(CompileTimeErrorCode.IMPLEMENTS_NON_CLASS, 59, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 59, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_inPart() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {} |
| '''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {} |
| '''); |
| newFile('/test/lib/part.dart', content: ''' |
| part of lib; |
| class A extends N {} |
| '''); |
| newFile('/test/lib/lib.dart', content: ''' |
| library lib; |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| part 'part.dart'; |
| '''); |
| ResolvedUnitResult libResult = |
| await resolveFile(convertPath('/test/lib/lib.dart')); |
| ResolvedUnitResult partResult = |
| await resolveFile(convertPath('/test/lib/part.dart')); |
| expect(libResult.errors, hasLength(0)); |
| new GatheringErrorListener() |
| ..addAll(partResult.errors) |
| ..assertErrors([ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 29, 1), |
| error(CompileTimeErrorCode.EXTENDS_NON_CLASS, 29, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_instanceCreation() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| library L; |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| f() {new N();}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 60, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_is() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| f(p) {p is N;}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 51, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_qualifier() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| g() { N.FOO; }''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 46, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_typeAnnotation() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| 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> {}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 48, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 53, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 59, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 63, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 72, 1), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 74, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 106, 1), |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 149, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_typeArgument_annotation() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| class A<T> {} |
| A<N> f() { return null; }''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 56, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_typeArgument_instanceCreation() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class N {}'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| class N {}'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| class A<T> {} |
| f() {new A<N>();}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 65, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_varRead() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| var v;'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| var v;'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| f() { g(v); } |
| g(p) {}''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 48, 1), |
| ]); |
| } |
| |
| test_ambiguousImport_varWrite() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| var v;'''); |
| newFile("/test/lib/lib2.dart", content: ''' |
| library lib2; |
| var v;'''); |
| await assertErrorsInCode(''' |
| import 'lib1.dart'; |
| import 'lib2.dart'; |
| f() { v = 0; }''', [ |
| error(StaticWarningCode.AMBIGUOUS_IMPORT, 46, 1), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_ambiguousClassName() async { |
| // See dartbug.com/19624 |
| newFile("/test/lib/lib2.dart", content: ''' |
| class _A {} |
| g(h(_A a)) {}'''); |
| await assertErrorsInCode(''' |
| import 'lib2.dart'; |
| class _A {} |
| f() { |
| g((_A a) {}); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 42, 9), |
| ]); |
| // 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. |
| String message = result.errors[0].message; |
| expect(message.indexOf("_A") >= 0, isTrue); |
| } |
| |
| test_argumentTypeNotAssignable_annotation_namedConstructor() async { |
| await assertErrorsInCode(''' |
| class A { |
| const A.fromInt(int p); |
| } |
| @A.fromInt('0') |
| main() { |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 49, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_annotation_unnamedConstructor() async { |
| await assertErrorsInCode(''' |
| class A { |
| const A(int p); |
| } |
| @A('0') |
| main() { |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 33, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_binary() async { |
| await assertErrorsInCode(''' |
| class A { |
| operator +(int p) {} |
| } |
| f(A a) { |
| a + '0'; |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 50, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_call() async { |
| await assertErrorsInCode(''' |
| typedef bool Predicate<T>(T object); |
| |
| Predicate<String> f() => null; |
| |
| void main() { |
| f().call(3); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 95, 1), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_cascadeSecond() async { |
| await assertErrorsInCode(''' |
| // 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); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 186, 1), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_const() async { |
| await assertErrorsInCode(''' |
| class A { |
| const A(String p); |
| } |
| main() { |
| const A(42); |
| }''', [ |
| error( |
| CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH, |
| 52, |
| 2), |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 52, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_const_super() async { |
| await assertErrorsInCode(''' |
| class A { |
| const A(String p); |
| } |
| class B extends A { |
| const B() : super(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 73, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_functionExpressionInvocation_required() async { |
| await assertErrorsInCode(''' |
| main() { |
| (int x) {} (''); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 23, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_index() async { |
| await assertErrorsInCode(''' |
| class A { |
| operator [](int index) {} |
| } |
| f(A a) { |
| a['0']; |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 53, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_callParameter() async { |
| await assertErrorsInCode(''' |
| class A { |
| call(int p) {} |
| } |
| f(A a) { |
| a('0'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 42, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_callVariable() async { |
| await assertErrorsInCode(''' |
| class A { |
| call(int p) {} |
| } |
| main() { |
| A a = new A(); |
| a('0'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 59, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_functionParameter() async { |
| await assertErrorsInCode(''' |
| a(b(int p)) { |
| b('0'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 18, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_functionParameter_generic() async { |
| await assertErrorsInCode(''' |
| class A<K, V> { |
| m(f(K k), V v) { |
| f(v); |
| } |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 41, 1), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_functionTypes_optional() async { |
| await assertErrorsInCode(''' |
| void acceptFunNumOptBool(void funNumOptBool([bool b])) {} |
| void funNumBool(bool b) {} |
| main() { |
| acceptFunNumOptBool(funNumBool); |
| }''', [ |
| error(StrongModeCode.INVALID_CAST_FUNCTION, 116, 10), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_generic() async { |
| await assertErrorsInCode(''' |
| class A<T> { |
| m(T t) {} |
| } |
| f(A<String> a) { |
| a.m(1); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 50, 1), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_named() async { |
| await assertErrorsInCode(''' |
| f({String p}) {} |
| main() { |
| f(p: 42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 30, 5), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_optional() async { |
| await assertErrorsInCode(''' |
| f([String p]) {} |
| main() { |
| f(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 30, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_required() async { |
| await assertErrorsInCode(''' |
| f(String p) {} |
| main() { |
| f(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 28, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_typedef_generic() async { |
| await assertErrorsInCode(''' |
| typedef A<T>(T p); |
| f(A<int> a) { |
| a('1'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 37, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_typedef_local() async { |
| await assertErrorsInCode(''' |
| typedef A(int p); |
| A getA() => null; |
| main() { |
| A a = getA(); |
| a('1'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 65, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_invocation_typedef_parameter() async { |
| await assertErrorsInCode(''' |
| typedef A(int p); |
| f(A a) { |
| a('1'); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 31, 3), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_new_generic() async { |
| await assertErrorsInCode(''' |
| class A<T> { |
| A(T p) {} |
| } |
| main() { |
| new A<String>(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 52, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_new_optional() async { |
| await assertErrorsInCode(''' |
| class A { |
| A([String p]) {} |
| } |
| main() { |
| new A(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 48, 2), |
| ]); |
| } |
| |
| test_argumentTypeNotAssignable_new_required() async { |
| await assertErrorsInCode(''' |
| class A { |
| A(String p) {} |
| } |
| main() { |
| new A(42); |
| }''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 46, 2), |
| ]); |
| } |
| |
| @failingTest |
| test_argumentTypeNotAssignable_tearOff_required() async { |
| await assertErrorsInCode(''' |
| class C { |
| Object/*=T*/ f/*<T>*/(Object/*=T*/ x) => x; |
| } |
| g(C c) { |
| var h = c.f/*<int>*/; |
| print(h('s')); |
| } |
| ''', [ |
| error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 99, 1), |
| ]); |
| } |
| |
| test_assignmentToClass() async { |
| await assertErrorsInCode(''' |
| class C {} |
| main() { |
| C = null; |
| } |
| ''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_TYPE, 22, 1), |
| ]); |
| } |
| |
| test_assignmentToConst_instanceVariable() async { |
| await assertErrorsInCode(''' |
| class A { |
| static const v = 0; |
| } |
| f() { |
| A.v = 1; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_CONST, 42, 3), |
| ]); |
| } |
| |
| test_assignmentToConst_instanceVariable_plusEq() async { |
| await assertErrorsInCode(''' |
| class A { |
| static const v = 0; |
| } |
| f() { |
| A.v += 1; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_CONST, 42, 3), |
| ]); |
| } |
| |
| test_assignmentToConst_localVariable() async { |
| await assertErrorsInCode(''' |
| f() { |
| const x = 0; |
| x = 1; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_CONST, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToConst_localVariable_plusEq() async { |
| await assertErrorsInCode(''' |
| f() { |
| const x = 0; |
| x += 1; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_CONST, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToEnumType() async { |
| await assertErrorsInCode(''' |
| enum E { e } |
| main() { |
| E = null; |
| } |
| ''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_TYPE, 24, 1), |
| ]); |
| } |
| |
| test_assignmentToFinal_instanceVariable() async { |
| await assertErrorsInCode(''' |
| class A { |
| final v = 0; |
| } |
| f() { |
| A a = new A(); |
| a.v = 1; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL, 54, 1), |
| ]); |
| } |
| |
| test_assignmentToFinal_instanceVariable_plusEq() async { |
| await assertErrorsInCode(''' |
| class A { |
| final v = 0; |
| } |
| f() { |
| A a = new A(); |
| a.v += 1; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL, 54, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_localVariable() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x = 1; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_localVariable_plusEq() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x += 1; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_parameter() async { |
| await assertErrorsInCode(''' |
| f(final x) { |
| x = 1; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 15, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_postfixMinusMinus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x--; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_postfixPlusPlus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x++; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_prefixMinusMinus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| --x; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 25, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_prefixPlusPlus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| ++x; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 25, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_suffixMinusMinus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x--; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_suffixPlusPlus() async { |
| await assertErrorsInCode(''' |
| f() { |
| final x = 0; |
| x++; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 23, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalLocal_topLevelVariable() async { |
| await assertErrorsInCode(''' |
| final x = 0; |
| f() { x = 1; }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_LOCAL, 19, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalNoSetter_prefixedIdentifier() async { |
| await assertErrorsInCode(''' |
| class A { |
| int get x => 0; |
| } |
| main() { |
| A a = new A(); |
| a.x = 0; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, 60, 1), |
| ]); |
| } |
| |
| test_assignmentToFinalNoSetter_propertyAccess() async { |
| await assertErrorsInCode(''' |
| class A { |
| int get x => 0; |
| } |
| class B { |
| static A a; |
| } |
| main() { |
| B.a.x = 0; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, 71, 1), |
| ]); |
| } |
| |
| test_assignmentToFunction() async { |
| await assertErrorsInCode(''' |
| f() {} |
| main() { |
| f = null; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_FUNCTION, 18, 1), |
| ]); |
| } |
| |
| test_assignmentToMethod() async { |
| await assertErrorsInCode(''' |
| class A { |
| m() {} |
| } |
| f(A a) { |
| a.m = () {}; |
| }''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_METHOD, 32, 3), |
| ]); |
| } |
| |
| test_assignmentToTypedef() async { |
| await assertErrorsInCode(''' |
| typedef void F(); |
| main() { |
| F = null; |
| } |
| ''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_TYPE, 29, 1), |
| ]); |
| } |
| |
| test_assignmentToTypeParameter() async { |
| await assertErrorsInCode(''' |
| class C<T> { |
| f() { |
| T = null; |
| } |
| } |
| ''', [ |
| error(StaticWarningCode.ASSIGNMENT_TO_TYPE, 25, 1), |
| ]); |
| } |
| |
| test_caseBlockNotTerminated() async { |
| await assertErrorsInCode(''' |
| f(int p) { |
| switch (p) { |
| case 0: |
| f(p); |
| case 1: |
| break; |
| } |
| }''', [ |
| error(StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, 30, 4), |
| ]); |
| } |
| |
| test_castToNonType() async { |
| await assertErrorsInCode(''' |
| var A = 0; |
| f(String s) { var x = s as A; }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 29, 1), |
| error(StaticWarningCode.CAST_TO_NON_TYPE, 38, 1), |
| ]); |
| } |
| |
| test_concreteClassWithAbstractMember() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(); |
| }''', [ |
| error(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, 12, 4), |
| ]); |
| } |
| |
| test_concreteClassWithAbstractMember_noSuchMethod_interface() async { |
| await assertErrorsInCode(''' |
| class I { |
| noSuchMethod(v) => ''; |
| } |
| class A implements I { |
| m(); |
| }''', [ |
| error(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, 62, 4), |
| ]); |
| } |
| |
| test_constWithAbstractClass() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| const A(); |
| } |
| void f() { |
| A a = const A(); |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 49, 1), |
| error(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, 59, 1), |
| ]); |
| } |
| |
| test_constWithAbstractClass_generic() async { |
| await assertErrorsInCode(''' |
| abstract class A<E> { |
| const A(); |
| } |
| void f() { |
| var a = const A<int>(); |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 54, 1), |
| error(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, 64, 6), |
| ]); |
| |
| ClassDeclaration classA = result.unit.declarations[0]; |
| FunctionDeclaration f = result.unit.declarations[1]; |
| BlockFunctionBody body = f.functionExpression.body; |
| VariableDeclarationStatement a = body.block.statements[0]; |
| InstanceCreationExpression init = a.variables.variables[0].initializer; |
| expect(init.staticType, |
| classA.declaredElement.type.instantiate([typeProvider.intType])); |
| } |
| |
| test_exportDuplicatedLibraryNamed() async { |
| newFile("/test/lib/lib1.dart", content: "library lib;"); |
| newFile("/test/lib/lib2.dart", content: "library lib;"); |
| await assertErrorsInCode(''' |
| library test; |
| export 'lib1.dart'; |
| export 'lib2.dart';''', [ |
| error(StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED, 34, 19), |
| ]); |
| } |
| |
| test_extraPositionalArguments() async { |
| await assertErrorsInCode(''' |
| f() {} |
| main() { |
| f(0, 1, '2'); |
| }''', [ |
| error(StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS, 19, 11), |
| ]); |
| } |
| |
| test_extraPositionalArguments_functionExpression() async { |
| await assertErrorsInCode(''' |
| main() { |
| (int x) {} (0, 1); |
| }''', [ |
| error(StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS, 22, 6), |
| ]); |
| } |
| |
| test_extraPositionalArgumentsCouldBeNamed() async { |
| await assertErrorsInCode(''' |
| f({x, y}) {} |
| main() { |
| f(0, 1, '2'); |
| }''', [ |
| error( |
| StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS_COULD_BE_NAMED, 25, 11), |
| ]); |
| } |
| |
| test_extraPositionalArgumentsCouldBeNamed_functionExpression() async { |
| await assertErrorsInCode(''' |
| main() { |
| (int x, {int y}) {} (0, 1); |
| }''', [ |
| error(StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS_COULD_BE_NAMED, 31, 6), |
| ]); |
| } |
| |
| test_fieldInitializedInInitializerAndDeclaration_final() async { |
| await assertErrorsInCode(''' |
| class A { |
| final int x = 0; |
| A() : x = 1 {} |
| }''', [ |
| error(StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, |
| 37, 1), |
| ]); |
| } |
| |
| test_fieldInitializerNotAssignable() async { |
| await assertErrorsInCode(''' |
| class A { |
| int x; |
| A() : x = ''; |
| }''', [ |
| error(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, 31, 2), |
| ]); |
| } |
| |
| test_fieldInitializingFormalNotAssignable() async { |
| await assertErrorsInCode(''' |
| class A { |
| int x; |
| A(String this.x) {} |
| }''', [ |
| error(StrongModeCode.INVALID_PARAMETER_DECLARATION, 23, 13), |
| error(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, 23, 13), |
| ]); |
| } |
| |
| /** |
| * 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 |
| */ |
| test_finalInitializedInDeclarationAndConstructor_initializers() async { |
| await assertErrorsInCode(''' |
| class A { |
| final x = 0; |
| A() : x = 0 {} |
| }''', [ |
| error(StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, |
| 33, 1), |
| ]); |
| } |
| |
| test_finalInitializedInDeclarationAndConstructor_initializingFormal() async { |
| await assertErrorsInCode(''' |
| class A { |
| final x = 0; |
| A(this.x) {} |
| }''', [ |
| error(StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, |
| 34, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_inConstructor_1() async { |
| await assertErrorsInCode(''' |
| class A { |
| final int x; |
| A() {} |
| }''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_1, 27, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_inConstructor_2() async { |
| await assertErrorsInCode(''' |
| class A { |
| final int a; |
| final int b; |
| A() {} |
| }''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_2, 42, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_inConstructor_3() async { |
| await assertErrorsInCode(''' |
| class A { |
| final int a; |
| final int b; |
| final int c; |
| A() {} |
| }''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS, 57, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_instanceField_final() async { |
| await assertErrorsInCode(''' |
| class A { |
| final F; |
| }''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED, 18, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_instanceField_final_static() async { |
| await assertErrorsInCode(''' |
| class A { |
| static final F; |
| }''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED, 25, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_library_final() async { |
| await assertErrorsInCode(''' |
| final F; |
| ''', [ |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED, 6, 1), |
| ]); |
| } |
| |
| test_finalNotInitialized_local_final() async { |
| await assertErrorsInCode(''' |
| f() { |
| final int x; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 18, 1), |
| error(StaticWarningCode.FINAL_NOT_INITIALIZED, 18, 1), |
| ]); |
| } |
| |
| test_functionWithoutCall_direct() async { |
| await assertNoErrorsInCode(''' |
| class A implements Function { |
| }'''); |
| } |
| |
| test_functionWithoutCall_direct_typeAlias() async { |
| await assertNoErrorsInCode(''' |
| class M {} |
| class A = Object with M implements Function;'''); |
| } |
| |
| test_functionWithoutCall_indirect_extends() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function { |
| } |
| class B extends A { |
| }'''); |
| } |
| |
| test_functionWithoutCall_indirect_extends_typeAlias() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function {} |
| class M {} |
| class B = A with M;'''); |
| } |
| |
| test_functionWithoutCall_indirect_implements() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function { |
| } |
| class B implements A { |
| }'''); |
| } |
| |
| test_functionWithoutCall_indirect_implements_typeAlias() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function {} |
| class M {} |
| class B = Object with M implements A;'''); |
| } |
| |
| test_functionWithoutCall_mixin_implements() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function {} |
| class B extends Object with A {}'''); |
| } |
| |
| test_functionWithoutCall_mixin_implements_typeAlias() async { |
| await assertNoErrorsInCode(''' |
| abstract class A implements Function {} |
| class B = Object with A;'''); |
| } |
| |
| test_generalizedVoid_andVoidLhsError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x && true; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 26, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_andVoidRhsError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| true && x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 34, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_assignmentToVoidParameterOk() async { |
| // Note: the spec may decide to disallow this, but at this point that seems |
| // highly unlikely. |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| f(x); |
| } |
| void f(void x) {} |
| '''); |
| } |
| |
| test_generalizedVoid_assignToVoid_notStrong_error() async { |
| // See StrongModeStaticTypeAnalyzer2Test.test_generalizedVoid_assignToVoidOk |
| // for testing that this does not have errors in strong mode. |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| x = 42; |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_interpolateVoidValueError() async { |
| await assertErrorsInCode(r''' |
| void main() { |
| void x; |
| "$x"; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 28, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_negateVoidValueError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| !x; |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 21, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 27, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_orVoidLhsError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x || true; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 26, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_orVoidRhsError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| false || x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 35, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_throwVoidValueError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| throw x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 32, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_unaryNegativeVoidValueError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| -x; |
| } |
| ''', [ |
| // TODO(mfairhurst) suppress UNDEFINED_OPERATOR |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 21, 1), |
| error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 26, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 27, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfInForeachIterableError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| for (var v in x) {} |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 35, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 40, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidAsIndexAssignError() async { |
| await assertErrorsInCode(''' |
| void main(List list) { |
| void x; |
| list[x] = null; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 40, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidAsIndexError() async { |
| await assertErrorsInCode(''' |
| void main(List list) { |
| void x; |
| list[x]; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 40, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidAssignedToDynamicError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| dynamic z = x; |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 34, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 38, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidByIndexingError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x[0]; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 27, 3), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidCallSetterError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x.foo = null; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 28, 3), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidCastsOk() async { |
| await assertNoErrorsInCode(''' |
| void use(dynamic x) { } |
| void main() { |
| void x; |
| use(x as int); |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInConditionalConditionError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x ? null : null; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 26, 1), |
| ]); |
| } |
| |
| @failingTest |
| test_generalizedVoid_useOfVoidInConditionalLhsError() async { |
| // TODO(mfairhurst) Enable this. |
| await assertErrorsInCode(''' |
| void main(bool c) { |
| void x; |
| c ? x : null; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 36, 1), |
| ]); |
| } |
| |
| @failingTest |
| test_generalizedVoid_useOfVoidInConditionalRhsError() async { |
| // TODO(mfairhurst) Enable this. |
| await assertErrorsInCode(''' |
| void main(bool c) { |
| void x; |
| c ? null : x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 43, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInDoWhileConditionError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| do {} while (x); |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 39, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInExpStmtOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| x; |
| } |
| '''); |
| } |
| |
| @failingTest // This test may be completely invalid. |
| test_generalizedVoid_useOfVoidInForeachVariableError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| for (x in [1, 2]) {} |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 31, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInForPartsOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| for (x; false; x) {} |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInIsTestError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x is int; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 26, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInListLiteralError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| <dynamic>[x]; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 36, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInListLiteralOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| <void>[x]; // not strong mode; we have to specify <void>. |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInMapLiteralKeyError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| var m2 = <dynamic, int>{x : 4}; |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 30, 2), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 50, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInMapLiteralKeyOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| var m2 = <void, int>{x : 4}; // not strong mode; we have to specify <void>. |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInMapLiteralValueError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| var m1 = <int, dynamic>{4: x}; |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 30, 2), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 53, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInMapLiteralValueOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| var m1 = <int, void>{4: x}; // not strong mode; we have to specify <void>. |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInNullOperatorLhsError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x ?? 499; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 26, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInNullOperatorRhsOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| null ?? x; |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidInSpecialAssignmentError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x += 1; |
| } |
| ''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 21, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 28, 2), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInSwitchExpressionError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| switch(x) {} |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 33, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidInWhileConditionError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| while (x) {}; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 33, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidNullPropertyAccessError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x?.foo; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 29, 3), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidPropertyAccessError() async { |
| await assertErrorsInCode(''' |
| void main() { |
| void x; |
| x.foo; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 28, 3), |
| ]); |
| } |
| |
| @failingTest |
| test_generalizedVoid_useOfVoidReturnInNonVoidFunctionError() async { |
| // TODO(mfairhurst) Get this test to pass once codebase is compliant. |
| await assertErrorsInCode(''' |
| dynamic main() { |
| void x; |
| return x; |
| } |
| ''', [ |
| error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, 36, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidReturnInVoidFunctionOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| return x; |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_useOfVoidWhenArgumentError() async { |
| await assertErrorsInCode(''' |
| void use(dynamic x) { } |
| void main() { |
| void x; |
| use(x); |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 54, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_useOfVoidWithInitializerOk() async { |
| await assertNoErrorsInCode(''' |
| void main() { |
| void x; |
| void y = x; |
| } |
| '''); |
| } |
| |
| test_generalizedVoid_yieldStarVoid_asyncStar() async { |
| await assertErrorsInCode(''' |
| main(void x) async* { |
| yield* x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 31, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_yieldStarVoid_syncStar() async { |
| await assertErrorsInCode(''' |
| main(void x) sync* { |
| yield* x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 30, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_yieldVoid_asyncStar() async { |
| await assertErrorsInCode(''' |
| main(void x) async* { |
| yield x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 30, 1), |
| ]); |
| } |
| |
| test_generalizedVoid_yieldVoid_syncStar() async { |
| await assertErrorsInCode(''' |
| main(void x) sync* { |
| yield x; |
| } |
| ''', [ |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 29, 1), |
| ]); |
| } |
| |
| test_importDuplicatedLibraryNamed() async { |
| newFile("/test/lib/lib1.dart", content: "library lib;"); |
| newFile("/test/lib/lib2.dart", content: "library lib;"); |
| assertErrorsInCode(''' |
| library test; |
| import 'lib1.dart'; |
| import 'lib2.dart';''', [ |
| error(HintCode.UNUSED_IMPORT, 21, 11), |
| error(StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED, 34, 19), |
| error(HintCode.UNUSED_IMPORT, 41, 11), |
| ]); |
| } |
| |
| test_importOfNonLibrary() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| part of lib; |
| class A {}'''); |
| assertErrorsInCode(''' |
| library lib; |
| import 'lib1.dart' deferred as p; |
| var a = new p.A();''', [ |
| error(StaticWarningCode.IMPORT_OF_NON_LIBRARY, 20, 11), |
| ]); |
| } |
| |
| test_invalidGetterOverrideReturnType() async { |
| await assertErrorsInCode(''' |
| class A { |
| int get g { return 0; } |
| } |
| class B extends A { |
| String get g { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 60, 28), |
| ]); |
| } |
| |
| test_invalidGetterOverrideReturnType_implicit() async { |
| await assertErrorsInCode(''' |
| class A { |
| String f; |
| } |
| class B extends A { |
| int f; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 46, 5), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 46, 5), |
| ]); |
| } |
| |
| test_invalidGetterOverrideReturnType_twoInterfaces() async { |
| // test from language/override_inheritance_field_test_11.dart |
| await assertErrorsInCode(''' |
| 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; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 152, 26), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 152, 26), |
| ]); |
| } |
| |
| test_invalidGetterOverrideReturnType_twoInterfaces_conflicting() async { |
| await assertErrorsInCode(''' |
| 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; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 127, 21), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 127, 21), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNamedParamType() async { |
| await assertErrorsInCode(''' |
| class A { |
| m({int a}) {} |
| } |
| class B implements A { |
| m({String a}) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 53, 16), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNormalParamType_interface() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(int a) {} |
| } |
| class B implements A { |
| m(String a) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 51, 14), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNormalParamType_superclass() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(int a) {} |
| } |
| class B extends A { |
| m(String a) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 48, 14), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNormalParamType_superclass_interface() async { |
| await assertErrorsInCode(''' |
| 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) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 132, 14), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 132, 14), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNormalParamType_twoInterfaces() async { |
| await assertErrorsInCode(''' |
| 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) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 124, 14), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 124, 14), |
| ]); |
| } |
| |
| test_invalidMethodOverrideNormalParamType_twoInterfaces_conflicting() async { |
| // language/override_inheritance_generic_test/08 |
| await assertErrorsInCode(''' |
| 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) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 125, 14), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 125, 14), |
| ]); |
| } |
| |
| test_invalidMethodOverrideOptionalParamType() async { |
| await assertErrorsInCode(''' |
| class A { |
| m([int a]) {} |
| } |
| class B implements A { |
| m([String a]) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 53, 16), |
| ]); |
| } |
| |
| test_invalidMethodOverrideOptionalParamType_twoInterfaces() async { |
| await assertErrorsInCode(''' |
| 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]) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 128, 16), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 128, 16), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_interface() async { |
| await assertErrorsInCode(''' |
| class A { |
| int m() { return 0; } |
| } |
| class B implements A { |
| String m() { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 61, 26), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_interface_grandparent() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| int m(); |
| } |
| abstract class B implements A { |
| } |
| class C implements B { |
| String m() { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 91, 26), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_mixin() async { |
| await assertErrorsInCode(''' |
| class A { |
| int m() { return 0; } |
| } |
| class B extends Object with A { |
| String m() { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 70, 26), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_superclass() async { |
| await assertErrorsInCode(''' |
| class A { |
| int m() { return 0; } |
| } |
| class B extends A { |
| String m() { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 58, 26), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_superclass_grandparent() async { |
| await assertErrorsInCode(''' |
| class A { |
| int m() { return 0; } |
| } |
| class B extends A { |
| } |
| class C extends B { |
| String m() { return 'a'; } |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 80, 26), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_twoInterfaces() async { |
| await assertErrorsInCode(''' |
| abstract class I { |
| int m(); |
| } |
| abstract class J { |
| num m(); |
| } |
| abstract class A implements I, J {} |
| class B extends A { |
| String m() => ''; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 122, 17), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 122, 17), |
| ]); |
| } |
| |
| test_invalidMethodOverrideReturnType_void() async { |
| await assertErrorsInCode(''' |
| class A { |
| int m() { return 0; } |
| } |
| class B extends A { |
| void m() {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 58, 11), |
| ]); |
| } |
| |
| test_invalidOverrideNamed_fewerNamedParameters() async { |
| await assertErrorsInCode(''' |
| class A { |
| m({a, b}) {} |
| } |
| class B extends A { |
| m({a}) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 49, 9), |
| ]); |
| } |
| |
| test_invalidOverrideNamed_missingNamedParameter() async { |
| await assertErrorsInCode(''' |
| class A { |
| m({a, b}) {} |
| } |
| class B extends A { |
| m({a, c}) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 49, 12), |
| ]); |
| } |
| |
| test_invalidOverridePositional_optional() async { |
| await assertErrorsInCode(''' |
| class A { |
| m([a, b]) {} |
| } |
| class B extends A { |
| m([a]) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 49, 9), |
| ]); |
| } |
| |
| test_invalidOverridePositional_optionalAndRequired() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(a, b, [c, d]) {} |
| } |
| class B extends A { |
| m(a, b, [c]) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 55, 15), |
| ]); |
| } |
| |
| test_invalidOverridePositional_optionalAndRequired2() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(a, b, [c, d]) {} |
| } |
| class B extends A { |
| m(a, [c, d]) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 55, 15), |
| ]); |
| } |
| |
| test_invalidOverrideRequired() async { |
| await assertErrorsInCode(''' |
| class A { |
| m(a) {} |
| } |
| class B extends A { |
| m(a, b) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 44, 10), |
| ]); |
| } |
| |
| test_invalidSetterOverrideNormalParamType() async { |
| await assertErrorsInCode(''' |
| class A { |
| void set s(int v) {} |
| } |
| class B extends A { |
| void set s(String v) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 57, 23), |
| ]); |
| } |
| |
| test_invalidSetterOverrideNormalParamType_superclass_interface() async { |
| await assertErrorsInCode(''' |
| 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; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 169, 31), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 169, 31), |
| ]); |
| } |
| |
| test_invalidSetterOverrideNormalParamType_twoInterfaces() async { |
| // test from language/override_inheritance_field_test_34.dart |
| await assertErrorsInCode(''' |
| 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; |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 162, 31), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 162, 31), |
| ]); |
| } |
| |
| test_invalidSetterOverrideNormalParamType_twoInterfaces_conflicting() async { |
| await assertErrorsInCode(''' |
| 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) {} |
| }''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 121, 18), |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 121, 18), |
| ]); |
| } |
| |
| test_mismatchedAccessorTypes_topLevel() async { |
| await assertErrorsInCode(''' |
| int get g { return 0; } |
| set g(String v) {}''', [ |
| error(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, 0, 23), |
| ]); |
| } |
| |
| test_missingEnumConstantInSwitch() async { |
| await assertErrorsInCode(''' |
| enum E { ONE, TWO, THREE, FOUR } |
| bool odd(E e) { |
| switch (e) { |
| case E.ONE: |
| case E.THREE: return true; |
| } |
| return false; |
| }''', [ |
| error(StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH, 51, 10), |
| error(StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH, 51, 10), |
| ]); |
| } |
| |
| test_mixedReturnTypes_localFunction() async { |
| await assertErrorsInCode(''' |
| class C { |
| m(int x) { |
| return (int y) { |
| if (y < 0) { |
| return; |
| } |
| return 0; |
| }; |
| } |
| }''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 71, 7), |
| ]); |
| } |
| |
| test_mixedReturnTypes_method() async { |
| await assertErrorsInCode(''' |
| class C { |
| m(int x) { |
| if (x < 0) { |
| return; |
| } |
| return 0; |
| } |
| }''', [ |
| error(StaticWarningCode.MIXED_RETURN_TYPES, 46, 6), |
| error(StaticWarningCode.MIXED_RETURN_TYPES, 64, 6), |
| ]); |
| } |
| |
| test_mixedReturnTypes_topLevelFunction() async { |
| await assertErrorsInCode(''' |
| f(int x) { |
| if (x < 0) { |
| return; |
| } |
| return 0; |
| }''', [ |
| error(StaticWarningCode.MIXED_RETURN_TYPES, 30, 6), |
| error(StaticWarningCode.MIXED_RETURN_TYPES, 44, 6), |
| ]); |
| } |
| |
| test_newWithAbstractClass() async { |
| await assertErrorsInCode(''' |
| abstract class A {} |
| void f() { |
| A a = new A(); |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 35, 1), |
| error(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, 43, 1), |
| ]); |
| } |
| |
| test_newWithAbstractClass_generic() async { |
| await assertErrorsInCode(''' |
| abstract class A<E> {} |
| void f() { |
| var a = new A<int>(); |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 40, 1), |
| error(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, 48, 6), |
| ]); |
| |
| ClassDeclaration classA = result.unit.declarations[0]; |
| FunctionDeclaration f = result.unit.declarations[1]; |
| BlockFunctionBody body = f.functionExpression.body; |
| VariableDeclarationStatement a = body.block.statements[0]; |
| InstanceCreationExpression init = a.variables.variables[0].initializer; |
| expect(init.staticType, |
| classA.declaredElement.type.instantiate([typeProvider.intType])); |
| } |
| |
| test_newWithInvalidTypeParameters() async { |
| await assertErrorsInCode(''' |
| class A {} |
| f() { return new A<A>(); }''', [ |
| error(StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS, 28, 4), |
| ]); |
| } |
| |
| test_newWithInvalidTypeParameters_tooFew() async { |
| await assertErrorsInCode(''' |
| class A {} |
| class C<K, V> {} |
| f(p) { |
| return new C<A>(); |
| }''', [ |
| error(StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS, 48, 4), |
| ]); |
| } |
| |
| test_newWithInvalidTypeParameters_tooMany() async { |
| await assertErrorsInCode(''' |
| class A {} |
| class C<E> {} |
| f(p) { |
| return new C<A, A>(); |
| }''', [ |
| error(StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS, 45, 7), |
| ]); |
| } |
| |
| test_newWithNonType() async { |
| await assertErrorsInCode(''' |
| var A = 0; |
| void f() { |
| var a = new A(); |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 28, 1), |
| error(StaticWarningCode.NEW_WITH_NON_TYPE, 36, 1), |
| ]); |
| } |
| |
| test_newWithNonType_fromLibrary() async { |
| newFile("/test/lib/lib.dart", content: "class B {}"); |
| await assertErrorsInCode(''' |
| import 'lib.dart' as lib; |
| void f() { |
| var a = new lib.A(); |
| } |
| lib.B b;''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1), |
| error(StaticWarningCode.NEW_WITH_NON_TYPE, 55, 1), |
| ]); |
| } |
| |
| test_newWithUndefinedConstructor() async { |
| await assertErrorsInCode(''' |
| class A { |
| A() {} |
| } |
| f() { |
| new A.name(); |
| }''', [ |
| error(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, 35, 4), |
| ]); |
| } |
| |
| test_newWithUndefinedConstructorDefault() async { |
| await assertErrorsInCode(''' |
| class A { |
| A.name() {} |
| } |
| f() { |
| new A(); |
| }''', [ |
| error(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, 38, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberFivePlus() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| m(); |
| n(); |
| o(); |
| p(); |
| q(); |
| } |
| class C extends A { |
| }''', [ |
| error( |
| StaticWarningCode |
| .NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS, |
| 62, |
| 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberFour() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| m(); |
| n(); |
| o(); |
| p(); |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR, |
| 55, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() async { |
| // 15979 |
| await assertErrorsInCode(''' |
| abstract class M {} |
| abstract class A {} |
| abstract class I { |
| m(); |
| } |
| class B = A with M implements I;''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 74, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin() async { |
| // 15979 |
| await assertErrorsInCode(''' |
| abstract class M { |
| m(); |
| } |
| abstract class A {} |
| class B = A with M;''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 54, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() async { |
| // 15979 |
| await assertErrorsInCode(''' |
| class M {} |
| abstract class A { |
| m(); |
| } |
| class B = A with M;''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 45, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() async { |
| // 15028 |
| await assertErrorsInCode(''' |
| class C { |
| foo(int x) => x; |
| } |
| abstract class D { |
| foo(x, [y]); |
| } |
| class E extends C implements D {}''', [ |
| error(CompileTimeErrorCode.INVALID_OVERRIDE, 73, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() async { |
| await assertErrorsInCode(''' |
| class I { |
| int get g {return 1;} |
| } |
| class C implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 42, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| int get g; |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 40, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface() async { |
| await assertErrorsInCode(''' |
| class I { |
| m(p) {} |
| } |
| class C implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 28, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface_abstractNSM() async { |
| await assertErrorsInCode(''' |
| class I { |
| m(p) {} |
| } |
| class C implements I { |
| noSuchMethod(v); |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 28, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface_abstractOverrideNSM() async { |
| await assertNoErrorsInCode(''' |
| class I { |
| m(p) {} |
| } |
| class B { |
| noSuchMethod(v) => null; |
| } |
| class C extends B implements I { |
| noSuchMethod(v); |
| }'''); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface_ifcNSM() async { |
| await assertErrorsInCode(''' |
| class I { |
| m(p) {} |
| noSuchMethod(v) => null; |
| } |
| class C implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 55, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| m(p); |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 35, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() async { |
| // 7640 |
| await assertErrorsInCode(''' |
| abstract class A { |
| int x(int a); |
| } |
| abstract class B { |
| int x(int a, [int b]); |
| } |
| class C implements A, B { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 89, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_getter() async { |
| // 15001 |
| await assertErrorsInCode(''' |
| abstract class A { get g1; get g2; } |
| abstract class B implements A { get g1 => 1; } |
| class C extends Object with B {}''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 90, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_method() async { |
| // 15001 |
| await assertErrorsInCode(''' |
| abstract class A { m1(); m2(); } |
| abstract class B implements A { m1() => 1; } |
| class C extends Object with B {}''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 84, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_setter() async { |
| // 15001 |
| await assertErrorsInCode(''' |
| abstract class A { set s1(v); set s2(v); } |
| abstract class B implements A { set s1(v) {} } |
| class C extends Object with B {}''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 96, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_interface() async { |
| // 15979 |
| await assertErrorsInCode(''' |
| class I { |
| noSuchMethod(v) => ''; |
| } |
| abstract class A { |
| m(); |
| } |
| class B extends A implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 71, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter() async { |
| // test from language/override_inheritance_abstract_test_14.dart |
| await assertErrorsInCode(''' |
| abstract class A { |
| set field(_); |
| } |
| abstract class I { |
| var field; |
| } |
| class B extends A implements I { |
| get field => 0; |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 77, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() async { |
| await assertErrorsInCode(''' |
| class I { |
| set s(int i) {} |
| } |
| class C implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 36, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| set s(int i); |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 43, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface() async { |
| // bug 11154 |
| await assertErrorsInCode(''' |
| class A { |
| get a => 'a'; |
| } |
| abstract class B implements A { |
| get b => 'b'; |
| } |
| class C extends B { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 84, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter() async { |
| // 16133 |
| await assertErrorsInCode(''' |
| class I { |
| var v; |
| } |
| class C implements I { |
| set v(_) {} |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 27, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter() async { |
| // 16133 |
| await assertErrorsInCode(''' |
| class I { |
| var v; |
| } |
| class C implements I { |
| get v => 1; |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, |
| 27, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberThree() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| m(); |
| n(); |
| o(); |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, |
| 48, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberTwo() async { |
| await assertErrorsInCode(''' |
| abstract class A { |
| m(); |
| n(); |
| } |
| class C extends A { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, |
| 41, 1), |
| ]); |
| } |
| |
| test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth() async { |
| // 16133 |
| await assertErrorsInCode(''' |
| class I { |
| var v; |
| } |
| class C implements I { |
| }''', [ |
| error(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, |
| 27, 1), |
| ]); |
| } |
| |
| test_nonTypeInCatchClause_noElement() async { |
| await assertErrorsInCode(''' |
| f() { |
| try { |
| } on T catch (e) { |
| } |
| }''', [ |
| error(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, 21, 1), |
| error(HintCode.UNUSED_CATCH_CLAUSE, 30, 1), |
| ]); |
| } |
| |
| test_nonTypeInCatchClause_notType() async { |
| await assertErrorsInCode(''' |
| var T = 0; |
| f() { |
| try { |
| } on T catch (e) { |
| } |
| }''', [ |
| error(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, 32, 1), |
| error(HintCode.UNUSED_CATCH_CLAUSE, 41, 1), |
| ]); |
| } |
| |
| test_nonVoidReturnForOperator() async { |
| await assertErrorsInCode(''' |
| class A { |
| int operator []=(a, b) { return a; } |
| }''', [ |
| error(StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, 12, 3), |
| ]); |
| } |
| |
| test_nonVoidReturnForSetter_function() async { |
| await assertErrorsInCode(''' |
| int set x(int v) { |
| return 42; |
| }''', [ |
| error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 0, 3), |
| ]); |
| } |
| |
| test_nonVoidReturnForSetter_method() async { |
| await assertErrorsInCode(''' |
| class A { |
| int set x(int v) { |
| return 42; |
| } |
| }''', [ |
| error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 12, 3), |
| ]); |
| } |
| |
| test_notAType() async { |
| await assertErrorsInCode(''' |
| f() {} |
| main() { |
| f v = null; |
| }''', [ |
| error(StaticWarningCode.NOT_A_TYPE, 18, 1), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 20, 1), |
| ]); |
| } |
| |
| test_notEnoughRequiredArguments() async { |
| await assertErrorsInCode(''' |
| f(int a, String b) {} |
| main() { |
| f(); |
| }''', [ |
| error(StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS, 34, 2), |
| ]); |
| } |
| |
| test_notEnoughRequiredArguments_functionExpression() async { |
| await assertErrorsInCode(''' |
| main() { |
| (int x) {} (); |
| }''', [ |
| error(StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS, 22, 2), |
| ]); |
| } |
| |
| test_notEnoughRequiredArguments_getterReturningFunction() async { |
| await assertErrorsInCode(''' |
| typedef Getter(self); |
| Getter getter = (x) => x; |
| main() { |
| getter(); |
| }''', [ |
| error(StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS, 65, 2), |
| ]); |
| } |
| |
| test_partOfDifferentLibrary() async { |
| newFile("/test/lib/part.dart", content: "part of lub;"); |
| await assertErrorsInCode(''' |
| library lib; |
| part 'part.dart';''', [ |
| error(StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, 18, 11), |
| ]); |
| } |
| |
| test_redirectToInvalidFunctionType() async { |
| await assertErrorsInCode(''' |
| class A implements B { |
| A(int p) {} |
| } |
| class B { |
| factory B() = A; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE, 65, 1), |
| ]); |
| } |
| |
| test_redirectToInvalidReturnType() async { |
| await assertErrorsInCode(''' |
| class A { |
| A() {} |
| } |
| class B { |
| factory B() = A; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE, 47, 1), |
| ]); |
| } |
| |
| test_redirectToMissingConstructor_named() async { |
| await assertErrorsInCode(''' |
| class A implements B{ |
| A() {} |
| } |
| class B { |
| factory B() = A.name; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR, 59, 6), |
| ]); |
| } |
| |
| test_redirectToMissingConstructor_unnamed() async { |
| await assertErrorsInCode(''' |
| class A implements B{ |
| A.name() {} |
| } |
| class B { |
| factory B() = A; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR, 64, 1), |
| ]); |
| } |
| |
| test_redirectToNonClass_notAType() async { |
| await assertErrorsInCode(''' |
| class B { |
| int A; |
| factory B() = A; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_NON_CLASS, 35, 1), |
| ]); |
| } |
| |
| test_redirectToNonClass_undefinedIdentifier() async { |
| await assertErrorsInCode(''' |
| class B { |
| factory B() = A; |
| }''', [ |
| error(StaticWarningCode.REDIRECT_TO_NON_CLASS, 26, 1), |
| ]); |
| } |
| |
| test_returnWithoutValue_async() async { |
| await assertErrorsInCode(''' |
| import 'dart:async'; |
| Future<int> f() async { |
| return; |
| } |
| ''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 47, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_async_future_object_with_return() async { |
| await assertErrorsInCode(''' |
| import 'dart:async'; |
| Future<Object> f() async { |
| return; |
| } |
| ''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 50, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_factoryConstructor() async { |
| await assertErrorsInCode(''' |
| class A { factory A() { return; } } |
| ''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 24, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_function() async { |
| await assertErrorsInCode(''' |
| int f() { return; } |
| ''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 10, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_method() async { |
| await assertErrorsInCode(''' |
| class A { int m() { return; } } |
| ''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 20, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_mixedReturnTypes_function() async { |
| // Tests that only the RETURN_WITHOUT_VALUE warning is created, and no |
| // MIXED_RETURN_TYPES are created. |
| await assertErrorsInCode(''' |
| int f(int x) { |
| if (x < 0) { |
| return 1; |
| } |
| return; |
| }''', [ |
| error(StaticWarningCode.RETURN_WITHOUT_VALUE, 50, 7), |
| ]); |
| } |
| |
| test_returnWithoutValue_Null() async { |
| // Test that block bodied functions with return type Null and an empty |
| // return cause a static warning. |
| await assertNoErrorsInCode(''' |
| Null f() {return;} |
| '''); |
| } |
| |
| test_staticAccessToInstanceMember_method_invocation() async { |
| await assertErrorsInCode(''' |
| class A { |
| m() {} |
| } |
| main() { |
| A.m(); |
| }''', [ |
| error(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, 34, 1), |
| ]); |
| } |
| |
| test_staticAccessToInstanceMember_method_reference() async { |
| await assertErrorsInCode(''' |
| class A { |
| m() {} |
| } |
| main() { |
| A.m; |
| }''', [ |
| error(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, 34, 1), |
| ]); |
| } |
| |
| test_staticAccessToInstanceMember_propertyAccess_field() async { |
| await assertErrorsInCode(''' |
| class A { |
| var f; |
| } |
| main() { |
| A.f; |
| }''', [ |
| error(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, 34, 1), |
| ]); |
| } |
| |
| test_staticAccessToInstanceMember_propertyAccess_getter() async { |
| await assertErrorsInCode(''' |
| class A { |
| get f => 42; |
| } |
| main() { |
| A.f; |
| }''', [ |
| error(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, 40, 1), |
| ]); |
| } |
| |
| test_staticAccessToInstanceMember_propertyAccess_setter() async { |
| await assertErrorsInCode(''' |
| class A { |
| set f(x) {} |
| } |
| main() { |
| A.f = 42; |
| }''', [ |
| error(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, 39, 1), |
| ]); |
| } |
| |
| test_switchExpressionNotAssignable() async { |
| await assertErrorsInCode(''' |
| f(int p) { |
| switch (p) { |
| case 'a': break; |
| } |
| }''', [ |
| error(StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, 21, 1), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_asExpression() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| f(var v) { |
| v as a.A; |
| }''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 66, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_catchClause() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| f(var v) { |
| try { |
| } on a.A { |
| } |
| }''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 74, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_fieldFormalParameter() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| class C { |
| var v; |
| C(a.A this.v); |
| }''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 71, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_functionDeclaration_returnType() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| a.A f() { return null; }''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 48, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| f(a.A g()) {}''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 50, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_isExpression() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| f(var v) { |
| bool b = v is a.A; |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 66, 1), |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 75, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_methodDeclaration_returnType() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| class C { |
| a.A m() { return null; } |
| }''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 60, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_simpleFormalParameter() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| f(a.A v) {}''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 50, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_typeArgumentList() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| class C<E> {} |
| C<a.A> c;''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 64, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_typeArgumentList2() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| class C<E, F> {} |
| C<a.A, a.A> c;''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 67, 3), |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 72, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_typeParameter_bound() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| class C<E extends a.A> {}''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 66, 3), |
| ]); |
| } |
| |
| test_typeAnnotationDeferredClass_variableDeclarationList() async { |
| newFile("/test/lib/lib1.dart", content: ''' |
| library lib1; |
| class A {}'''); |
| await assertErrorsInCode(''' |
| library root; |
| import 'lib1.dart' deferred as a; |
| a.A v;''', [ |
| error(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, 48, 3), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_field() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static K k; |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 22, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_getter() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static K get k => null; |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 22, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_methodBodyReference() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static m() { |
| K k; |
| } |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 32, 1), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 34, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_methodParameter() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static m(K k) {} |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 24, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_methodReturn() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static K m() { return null; } |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 22, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_setter() async { |
| await assertErrorsInCode(''' |
| class A<K> { |
| static set s(K k) {} |
| }''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 28, 1), |
| ]); |
| } |
| |
| test_typeParameterReferencedByStatic_simpleIdentifier() async { |
| await assertErrorsInCode(''' |
| class A<T> { |
| static foo() { |
| T; |
| } |
| } |
| ''', [ |
| error(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, 34, 1), |
| ]); |
| } |
| |
| test_typePromotion_functionType_arg_InterToDyn() async { |
| await assertNoErrorsInCode(''' |
| typedef FuncDyn(x); |
| typedef FuncA(A a); |
| class A {} |
| class B {} |
| main(FuncA f) { |
| if (f is FuncDyn) { |
| f(new B()); |
| } |
| }'''); |
| } |
| |
| test_typeTestNonType() async { |
| await assertErrorsInCode(''' |
| var A = 0; |
| f(var p) { |
| if (p is A) { |
| } |
| }''', [ |
| error(StaticWarningCode.TYPE_TEST_WITH_NON_TYPE, 33, 1), |
| ]); |
| } |
| |
| test_typeTestWithUndefinedName() async { |
| await assertErrorsInCode(''' |
| f(var p) { |
| if (p is A) { |
| } |
| }''', [ |
| error(StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME, 22, 1), |
| ]); |
| } |
| |
| test_undefinedClass_instanceCreation() async { |
| await assertErrorsInCode(''' |
| f() { new C(); } |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_CLASS, 10, 1), |
| ]); |
| } |
| |
| test_undefinedClass_variableDeclaration() async { |
| await assertErrorsInCode(''' |
| f() { C c; } |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_CLASS, 6, 1), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 8, 1), |
| ]); |
| } |
| |
| test_undefinedClassBoolean_variableDeclaration() async { |
| await assertErrorsInCode(''' |
| f() { boolean v; } |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, 6, 7), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 14, 1), |
| ]); |
| } |
| |
| @failingTest |
| test_undefinedIdentifier_commentReference() async { |
| await assertErrorsInCode(''' |
| /** [m] xxx [new B.c] */ |
| class A { |
| }''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 5, 1), |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 17, 1), |
| ]); |
| } |
| |
| test_undefinedIdentifier_for() async { |
| await assertErrorsInCode(''' |
| f(var l) { |
| for (e in l) { |
| } |
| }''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 18, 1), |
| ]); |
| } |
| |
| test_undefinedIdentifier_function() async { |
| await assertErrorsInCode(''' |
| int a() => b; |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 11, 1), |
| ]); |
| } |
| |
| test_undefinedIdentifier_importCore_withShow() async { |
| await assertErrorsInCode(''' |
| import 'dart:core' show List; |
| main() { |
| List; |
| String; |
| }''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 49, 6), |
| ]); |
| } |
| |
| test_undefinedIdentifier_initializer() async { |
| await assertErrorsInCode(''' |
| var a = b; |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 8, 1), |
| ]); |
| } |
| |
| test_undefinedIdentifier_methodInvocation() async { |
| await assertErrorsInCode(''' |
| f() { C.m(); } |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 6, 1), |
| ]); |
| } |
| |
| test_undefinedIdentifier_private_getter() async { |
| newFile("/test/lib/lib.dart", content: ''' |
| library lib; |
| class A { |
| var _foo; |
| }'''); |
| await assertErrorsInCode(''' |
| import 'lib.dart'; |
| class B extends A { |
| test() { |
| var v = _foo; |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 58, 1), |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 62, 4), |
| ]); |
| } |
| |
| test_undefinedIdentifier_private_setter() async { |
| newFile("/test/lib/lib.dart", content: ''' |
| library lib; |
| class A { |
| var _foo; |
| }'''); |
| await assertErrorsInCode(''' |
| import 'lib.dart'; |
| class B extends A { |
| test() { |
| _foo = 42; |
| } |
| }''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER, 54, 4), |
| ]); |
| } |
| |
| test_undefinedIdentifierAwait_function() async { |
| await assertErrorsInCode(''' |
| void a() { await; } |
| ''', [ |
| error(StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT, 11, 5), |
| ]); |
| } |
| |
| test_undefinedNamedParameter() async { |
| await assertErrorsInCode(''' |
| f({a, b}) {} |
| main() { |
| f(c: 1); |
| }''', [ |
| error(StaticWarningCode.UNDEFINED_NAMED_PARAMETER, 26, 1), |
| ]); |
| } |
| |
| test_undefinedStaticMethodOrGetter_getter() async { |
| await assertErrorsInCode(''' |
| class C {} |
| f(var p) { |
| f(C.m); |
| }''', [ |
| error(StaticTypeWarningCode.UNDEFINED_GETTER, 28, 1), |
| ]); |
| } |
| |
| test_undefinedStaticMethodOrGetter_getter_inSuperclass() async { |
| await assertErrorsInCode(''' |
| class S { |
| static int get g => 0; |
| } |
| class C extends S {} |
| f(var p) { |
| f(C.g); |
| }''', [ |
| error(StaticTypeWarningCode.UNDEFINED_GETTER, 75, 1), |
| ]); |
| } |
| |
| test_undefinedStaticMethodOrGetter_setter_inSuperclass() async { |
| await assertErrorsInCode(''' |
| class S { |
| static set s(int i) {} |
| } |
| class C extends S {} |
| f(var p) { |
| f(C.s = 1); |
| }''', [ |
| error(StaticTypeWarningCode.UNDEFINED_SETTER, 75, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_assignmentExpression_function() async { |
| await assertErrorsInCode(''' |
| void f() {} |
| class A { |
| n() { |
| var a; |
| a = f(); |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 38, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 49, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_assignmentExpression_method() async { |
| await assertErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| var a; |
| a = m(); |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 40, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 51, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_await() async { |
| await assertNoErrorsInCode(''' |
| main() async { |
| void x; |
| await x; |
| }'''); |
| } |
| |
| test_useOfVoidResult_inForLoop_error() async { |
| await assertErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| for(Object a = m();;) {} |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 47, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 51, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_inForLoop_ok() async { |
| await assertNoErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| for(void a = m();;) {} |
| } |
| }'''); |
| } |
| |
| test_useOfVoidResult_variableDeclaration_function_error() async { |
| await assertErrorsInCode(''' |
| void f() {} |
| class A { |
| n() { |
| Object a = f(); |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 41, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 45, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_variableDeclaration_function_ok() async { |
| await assertNoErrorsInCode(''' |
| void f() {} |
| class A { |
| n() { |
| void a = f(); |
| } |
| }'''); |
| } |
| |
| test_useOfVoidResult_variableDeclaration_method2() async { |
| await assertErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| Object a = m(), b = m(); |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 47, 1), |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 52, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 56, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_variableDeclaration_method_error() async { |
| await assertErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| Object a = m(); |
| } |
| }''', [ |
| error(HintCode.UNUSED_LOCAL_VARIABLE, 43, 1), |
| error(StaticWarningCode.USE_OF_VOID_RESULT, 47, 1), |
| ]); |
| } |
| |
| test_useOfVoidResult_variableDeclaration_method_ok() async { |
| await assertNoErrorsInCode(''' |
| class A { |
| void m() {} |
| n() { |
| void a = m(); |
| } |
| }'''); |
| } |
| |
| test_voidReturnForGetter() async { |
| await assertNoErrorsInCode(''' |
| class S { |
| void get value {} |
| }'''); |
| } |
| } |