/*
* Copyright (c) 2013, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.engine.resolver;
import com.google.dart.engine.error.AnalysisError;
import com.google.dart.engine.error.CompileTimeErrorCode;
import com.google.dart.engine.error.ErrorCode;
import com.google.dart.engine.error.HintCode;
import com.google.dart.engine.error.StaticTypeWarningCode;
import com.google.dart.engine.error.StaticWarningCode;
import com.google.dart.engine.source.Source;
public class StaticWarningCodeTest extends ResolverTestCase {
public void fail_returnWithoutValue_async() throws Exception {
// TODO(paulberry): Some async/await type checking has not yet been fully backported from dart.
// See dartbug.com/22252.
Source source = addSource(createSource(//
"import 'dart:async';",
"Future<int> f() async {",
" return;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.RETURN_WITHOUT_VALUE);
verify(source);
}
public void fail_undefinedGetter() throws Exception {
Source source = addSource(createSource(//
// TODO
));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_GETTER);
verify(source);
}
public void fail_undefinedIdentifier_commentReference() throws Exception {
Source source = addSource(createSource(//
"/** [m] xxx [new B.c] */",
"class A {",
"}"));
resolve(source);
assertErrors(
source,
StaticWarningCode.UNDEFINED_IDENTIFIER,
StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void fail_undefinedSetter() throws Exception {
Source source = addSource(createSource(//
"class C {}",
"f(var p) {",
" C.m = 0;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_SETTER);
verify(source);
}
public void test_ambiguousImport_as() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"f(p) {p as N;}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_extends() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"class A extends N {}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT, CompileTimeErrorCode.EXTENDS_NON_CLASS);
}
public void test_ambiguousImport_implements() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"class A implements N {}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(
source,
StaticWarningCode.AMBIGUOUS_IMPORT,
CompileTimeErrorCode.IMPLEMENTS_NON_CLASS);
}
public void test_ambiguousImport_inPart() throws Exception {
Source source = addSource(createSource(//
"library lib;",
"import 'lib1.dart';",
"import 'lib2.dart';",
"part 'part.dart';"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
Source partSource = addNamedSource("/part.dart", createSource(//
"part of lib;",
"class A extends N {}"));
resolve(source);
assertErrors(
partSource,
StaticWarningCode.AMBIGUOUS_IMPORT,
CompileTimeErrorCode.EXTENDS_NON_CLASS);
}
public void test_ambiguousImport_instanceCreation() throws Exception {
Source source = addSource(createSource(//
"library L;",
"import 'lib1.dart';",
"import 'lib2.dart';",
"f() {new N();}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_is() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"f(p) {p is N;}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_qualifier() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"g() { N.FOO; }"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_typeAnnotation() throws Exception {
Source source = addSource(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", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", 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);
}
public void test_ambiguousImport_typeArgument_annotation() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"class A<T> {}",
"A<N> f() { return null; }"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_typeArgument_instanceCreation() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"class A<T> {}",
"f() {new A<N>();}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"class N {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"class N {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_varRead() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"f() { g(v); }",
"g(p) {}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"var v;"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"var v;"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_varWrite() throws Exception {
Source source = addSource(createSource(//
"import 'lib1.dart';",
"import 'lib2.dart';",
"f() { v = 0; }"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"var v;"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"var v;"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_ambiguousImport_withPrefix() throws Exception {
Source source = addSource(createSource(//
"library test;",
"import 'lib1.dart' as p;",
"import 'lib2.dart' as p;",
"main() {",
" p.f();",
"}"));
addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"f() {}"));
addNamedSource("/lib2.dart", createSource(//
"library lib2;",
"f() {}"));
resolve(source);
assertErrors(source, StaticWarningCode.AMBIGUOUS_IMPORT);
}
public void test_argumentTypeNotAssignable_ambiguousClassName() throws Exception {
// See dartbug.com/19624
Source source = addNamedSource("/lib1.dart", createSource(//
"library lib1;",
"import 'lib2.dart';",
"class _A {}",
"f() {",
" g((_A a) {});",
"}"));
addNamedSource("/lib2.dart", 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.
AnalysisError[] errors = analysisContext.computeErrors(source);
assertLength(1, errors);
AnalysisError error = errors[0];
assertEquals(error.getErrorCode(), StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
String message = error.getMessage();
assertTrue(message.indexOf("_A") != -1);
assertTrue(message.indexOf("lib1.dart") != -1);
assertTrue(message.indexOf("lib2.dart") != -1);
}
public void test_argumentTypeNotAssignable_annotation_namedConstructor() throws Exception {
Source source = addSource(createSource(//
"class A {",
" const A.fromInt(int p);",
"}",
"@A.fromInt('0')",
"main() {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_annotation_unnamedConstructor() throws Exception {
Source source = addSource(createSource(//
"class A {",
" const A(int p);",
"}",
"@A('0')",
"main() {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_binary() throws Exception {
Source source = addSource(createSource(//
"class A {",
" operator +(int p) {}",
"}",
"f(A a) {",
" a + '0';",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_cascadeSecond() throws Exception {
Source source = addSource(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);
}
public void test_argumentTypeNotAssignable_const() throws Exception {
Source source = addSource(createSource(//
"class A {",
" const A(String p);",
"}",
"main() {",
" const A(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_const_super() throws Exception {
Source source = addSource(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);
}
public void test_argumentTypeNotAssignable_functionExpressionInvocation_required()
throws Exception {
Source source = addSource(createSource(//
"main() {",
" (int x) {} ('');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_index() throws Exception {
Source source = addSource(createSource(//
"class A {",
" operator [](int index) {}",
"}",
"f(A a) {",
" a['0'];",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_callParameter() throws Exception {
Source source = addSource(createSource(//
"class A {",
" call(int p) {}",
"}",
"f(A a) {",
" a('0');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_callVariable() throws Exception {
Source source = addSource(createSource(//
"class A {",
" call(int p) {}",
"}",
"main() {",
" A a = new A();",
" a('0');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_functionParameter() throws Exception {
Source source = addSource(createSource(//
"a(b(int p)) {",
" b('0');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_functionParameter_generic()
throws Exception {
Source source = addSource(createSource(//
"class A<K, V> {",
" m(f(K k), V v) {",
" f(v);",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_functionTypes_optional() throws Exception {
Source source = addSource(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);
}
public void test_argumentTypeNotAssignable_invocation_generic() throws Exception {
Source source = addSource(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);
}
public void test_argumentTypeNotAssignable_invocation_named() throws Exception {
Source source = addSource(createSource(//
"f({String p}) {}",
"main() {",
" f(p: 42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_optional() throws Exception {
Source source = addSource(createSource(//
"f([String p]) {}",
"main() {",
" f(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_required() throws Exception {
Source source = addSource(createSource(//
"f(String p) {}",
"main() {",
" f(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_typedef_generic() throws Exception {
Source source = addSource(createSource(//
"typedef A<T>(T p);",
"f(A<int> a) {",
" a('1');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_invocation_typedef_local() throws Exception {
Source source = addSource(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);
}
public void test_argumentTypeNotAssignable_invocation_typedef_parameter() throws Exception {
Source source = addSource(createSource(//
"typedef A(int p);",
"f(A a) {",
" a('1');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_new_generic() throws Exception {
Source source = addSource(createSource(//
"class A<T> {",
" A(T p) {}",
"}",
"main() {",
" new A<String>(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_new_optional() throws Exception {
Source source = addSource(createSource(//
"class A {",
" A([String p]) {}",
"}",
"main() {",
" new A(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_argumentTypeNotAssignable_new_required() throws Exception {
Source source = addSource(createSource(//
"class A {",
" A(String p) {}",
"}",
"main() {",
" new A(42);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_assignmentToConst_instanceVariable() throws Exception {
Source source = addSource(createSource(//
"class A {",
" static const v = 0;",
"}",
"f() {",
" A.v = 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_CONST);
verify(source);
}
public void test_assignmentToConst_instanceVariable_plusEq() throws Exception {
Source source = addSource(createSource(//
"class A {",
" static const v = 0;",
"}",
"f() {",
" A.v += 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_CONST);
verify(source);
}
public void test_assignmentToConst_localVariable() throws Exception {
Source source = addSource(createSource(//
"f() {",
" const x = 0;",
" x = 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_CONST);
verify(source);
}
public void test_assignmentToConst_localVariable_plusEq() throws Exception {
Source source = addSource(createSource(//
"f() {",
" const x = 0;",
" x += 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_CONST);
verify(source);
}
public void test_assignmentToFinal_instanceVariable() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final v = 0;",
"}",
"f() {",
" A a = new A();",
" a.v = 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_instanceVariable_plusEq() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final v = 0;",
"}",
"f() {",
" A a = new A();",
" a.v += 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_localVariable() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x = 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_localVariable_plusEq() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x += 1;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_postfixMinusMinus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x--;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_postfixPlusPlus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x++;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_prefixMinusMinus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" --x;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_prefixPlusPlus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" ++x;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_suffixMinusMinus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x--;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_suffixPlusPlus() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final x = 0;",
" x++;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinal_topLevelVariable() throws Exception {
Source source = addSource(createSource(//
"final x = 0;",
"f() { x = 1; }"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FINAL);
verify(source);
}
public void test_assignmentToFinalNoSetter_prefixedIdentifier() throws Exception {
Source source = addSource(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);
}
public void test_assignmentToFinalNoSetter_propertyAccess() throws Exception {
Source source = addSource(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);
}
public void test_assignmentToFunction() throws Exception {
Source source = addSource(createSource(//
"f() {}",
"main() {",
" f = null;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_FUNCTION);
verify(source);
}
public void test_assignmentToMethod() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m() {}",
"}",
"f(A a) {",
" a.m = () {};",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ASSIGNMENT_TO_METHOD);
verify(source);
}
public void test_caseBlockNotTerminated() throws Exception {
Source source = addSource(createSource(//
"f(int p) {",
" switch (p) {",
" case 0:",
" f(p);",
" case 1:",
" break;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED);
verify(source);
}
public void test_castToNonType() throws Exception {
Source source = addSource(createSource(//
"var A = 0;",
"f(String s) { var x = s as A; }"));
resolve(source);
assertErrors(source, StaticWarningCode.CAST_TO_NON_TYPE);
verify(source);
}
public void test_concreteClassWithAbstractMember() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER);
verify(source);
}
public void test_conflictingDartImport() throws Exception {
Source source = addSource(createSource(//
"import 'lib.dart';",
"import 'dart:async';",
"Future f = null;",
"Stream s;"));
addNamedSource("/lib.dart", createSource(//
"library lib;",
"class Future {}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_DART_IMPORT);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter()
throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_getter()
throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_method()
throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_setter()
throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declGetter_indirect()
throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_declGetter_mixin() throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceGetterAndSuperclassMember_direct_field() throws Exception {
Source source = addSource(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);
}
public void test_conflictingInstanceMethodSetter_sameClass() throws Exception {
Source source = addSource(createSource(//
"class A {",
" set foo(a) {}",
" foo() {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER);
verify(source);
}
public void test_conflictingInstanceMethodSetter_setterInInterface() throws Exception {
Source source = addSource(createSource(//
"abstract class A {",
" set foo(a);",
"}",
"abstract class B implements A {",
" foo() {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER);
verify(source);
}
public void test_conflictingInstanceMethodSetter_setterInSuper() throws Exception {
Source source = addSource(createSource(//
"class A {",
" set foo(a) {}",
"}",
"class B extends A {",
" foo() {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER);
verify(source);
}
public void test_conflictingInstanceMethodSetter2() throws Exception {
Source source = addSource(createSource(//
"class A {",
" foo() {}",
" set foo(a) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2);
verify(source);
}
public void test_conflictingInstanceSetterAndSuperclassMember() throws Exception {
Source source = addSource(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);
}
public void test_conflictingStaticGetterAndInstanceSetter_mixin() throws Exception {
Source source = addSource(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);
}
public void test_conflictingStaticGetterAndInstanceSetter_superClass() throws Exception {
Source source = addSource(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);
}
public void test_conflictingStaticGetterAndInstanceSetter_thisClass() throws Exception {
Source source = addSource(createSource(//
"class A {",
" static get x => 0;",
" set x(int p) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER);
verify(source);
}
public void test_conflictingStaticSetterAndInstanceMember_thisClass_getter() throws Exception {
Source source = addSource(createSource(//
"class A {",
" get x => 0;",
" static set x(int p) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER);
verify(source);
}
public void test_conflictingStaticSetterAndInstanceMember_thisClass_method() throws Exception {
Source source = addSource(createSource(//
"class A {",
" x() {}",
" static set x(int p) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER);
verify(source);
}
public void test_constWithAbstractClass() throws Exception {
Source source = addSource(createSource(//
"abstract class A {",
" const A();",
"}",
"void f() {",
" A a = const A();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.CONST_WITH_ABSTRACT_CLASS);
verify(source);
}
public void test_equalKeysInMap() throws Exception {
Source source = addSource(createSource(//
"var m = {'a' : 0, 'b' : 1, 'a' : 2};"));
resolve(source);
assertErrors(source, StaticWarningCode.EQUAL_KEYS_IN_MAP);
verify(source);
}
public void test_equalKeysInMap_withEqualTypeParams() throws Exception {
Source source = addSource(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);
}
public void test_equalKeysInMap_withUnequalTypeParams() throws Exception {
// No error should be produced because A<int> and A<num> are different types.
Source source = addSource(createSource(//
"class A<T> {",
" const A();",
"}",
"var m = {const A<int>(): 0, const A<num>(): 1};"));
resolve(source);
assertNoErrors(source);
verify(source);
}
public void test_exportDuplicatedLibraryName() throws Exception {
Source source = addSource(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);
}
public void test_extraPositionalArguments() throws Exception {
Source source = addSource(createSource(//
"f() {}",
"main() {",
" f(0, 1, '2');",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS);
verify(source);
}
public void test_extraPositionalArguments_functionExpression() throws Exception {
Source source = addSource(createSource(//
"main() {",
" (int x) {} (0, 1);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS);
verify(source);
}
public void test_fieldInitializedInInitializerAndDeclaration_final() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final int x = 0;",
" A() : x = 1 {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION);
verify(source);
}
public void test_fieldInitializerNotAssignable() throws Exception {
Source source = addSource(createSource(//
"class A {",
" int x;",
" A() : x = '';",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE);
verify(source);
}
public void test_fieldInitializingFormalNotAssignable() throws Exception {
Source source = addSource(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.
* <p>
* 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
*/
public void test_finalInitializedInDeclarationAndConstructor_initializers() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final x = 0;",
" A() : x = 0 {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION);
verify(source);
}
public void test_finalInitializedInDeclarationAndConstructor_initializingFormal()
throws Exception {
Source source = addSource(createSource(//
"class A {",
" final x = 0;",
" A(this.x) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR);
verify(source);
}
public void test_finalNotInitialized_inConstructor() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final int x;",
" A() {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_NOT_INITIALIZED);
verify(source);
}
public void test_finalNotInitialized_instanceField_final() throws Exception {
Source source = addSource(createSource(//
"class A {",
" final F;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_NOT_INITIALIZED);
verify(source);
}
public void test_finalNotInitialized_instanceField_final_static() throws Exception {
Source source = addSource(createSource(//
"class A {",
" static final F;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_NOT_INITIALIZED);
verify(source);
}
public void test_finalNotInitialized_library_final() throws Exception {
Source source = addSource(createSource(//
"final F;"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_NOT_INITIALIZED);
verify(source);
}
public void test_finalNotInitialized_local_final() throws Exception {
Source source = addSource(createSource(//
"f() {",
" final int x;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FINAL_NOT_INITIALIZED);
verify(source);
}
public void test_functionWithoutCall_direct() throws Exception {
Source source = addSource(createSource(//
"class A implements Function {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FUNCTION_WITHOUT_CALL);
verify(source);
}
public void test_functionWithoutCall_indirect_extends() throws Exception {
Source source = addSource(createSource(//
"abstract class A implements Function {",
"}",
"class B extends A {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FUNCTION_WITHOUT_CALL);
verify(source);
}
public void test_functionWithoutCall_indirect_implements() throws Exception {
Source source = addSource(createSource(//
"abstract class A implements Function {",
"}",
"class B implements A {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.FUNCTION_WITHOUT_CALL);
verify(source);
}
public void test_importDuplicatedLibraryName() throws Exception {
Source source = addSource(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);
}
public void test_importOfNonLibrary() throws Exception {
resolve(new String[] {createSource(//
"part of lib;",
"class A {}"),//
createSource(//
"library lib;",
"import 'lib1.dart' deferred as p;",
"var a = new p.A();")}, new ErrorCode[] {StaticWarningCode.IMPORT_OF_NON_LIBRARY});
}
public void test_inconsistentMethodInheritanceGetterAndMethod() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_field() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_field2() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_getter() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_getter2() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_method() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_method2() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_setter() throws Exception {
Source source = addSource(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);
}
public void test_instanceMethodNameCollidesWithSuperclassStatic_setter2() throws Exception {
Source source = addSource(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);
}
public void test_invalidGetterOverrideReturnType() throws Exception {
Source source = addSource(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);
}
public void test_invalidGetterOverrideReturnType_implicit() throws Exception {
Source source = addSource(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);
}
public void test_invalidGetterOverrideReturnType_twoInterfaces() throws Exception {
// test from language/override_inheritance_field_test_11.dart
Source source = addSource(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);
}
public void test_invalidGetterOverrideReturnType_twoInterfaces_conflicting() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNamedParamType() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNormalParamType_interface() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNormalParamType_superclass() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNormalParamType_superclass_interface() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNormalParamType_twoInterfaces() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideNormalParamType_twoInterfaces_conflicting()
throws Exception {
// language/override_inheritance_generic_test/08
Source source = addSource(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);
}
public void test_invalidMethodOverrideOptionalParamType() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideOptionalParamType_twoInterfaces() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_interface() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_interface_grandparent() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_mixin() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_superclass() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_superclass_grandparent() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_twoInterfaces() throws Exception {
Source source = addSource(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);
}
public void test_invalidMethodOverrideReturnType_void() throws Exception {
Source source = addSource(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);
}
public void test_invalidOverrideDifferentDefaultValues_named() throws Exception {
Source source = addSource(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);
}
public void test_invalidOverrideDifferentDefaultValues_positional() throws Exception {
Source source = addSource(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);
}
public void test_invalidOverrideNamed_fewerNamedParameters() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m({a, b}) {}",
"}",
"class B extends A {",
" m({a}) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.INVALID_OVERRIDE_NAMED);
verify(source);
}
public void test_invalidOverrideNamed_missingNamedParameter() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m({a, b}) {}",
"}",
"class B extends A {",
" m({a, c}) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.INVALID_OVERRIDE_NAMED);
verify(source);
}
public void test_invalidOverridePositional_optional() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m([a, b]) {}",
"}",
"class B extends A {",
" m([a]) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.INVALID_OVERRIDE_POSITIONAL);
verify(source);
}
public void test_invalidOverridePositional_optionalAndRequired() throws Exception {
Source source = addSource(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);
}
public void test_invalidOverridePositional_optionalAndRequired2() throws Exception {
Source source = addSource(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);
}
public void test_invalidOverrideRequired() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m(a) {}",
"}",
"class B extends A {",
" m(a, b) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.INVALID_OVERRIDE_REQUIRED);
verify(source);
}
public void test_invalidSetterOverrideNormalParamType() throws Exception {
Source source = addSource(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);
}
public void test_invalidSetterOverrideNormalParamType_superclass_interface() throws Exception {
Source source = addSource(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);
}
public void test_invalidSetterOverrideNormalParamType_twoInterfaces() throws Exception {
// test from language/override_inheritance_field_test_34.dart
Source source = addSource(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);
}
public void test_invalidSetterOverrideNormalParamType_twoInterfaces_conflicting()
throws Exception {
Source source = addSource(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);
}
public void test_listElementTypeNotAssignable() throws Exception {
Source source = addSource(createSource(//
"var v = <String> [42];"));
resolve(source);
assertErrors(source, StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_mapKeyTypeNotAssignable() throws Exception {
Source source = addSource(createSource(//
"var v = <String, int > {1 : 2};"));
resolve(source);
assertErrors(source, StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_mapValueTypeNotAssignable() throws Exception {
Source source = addSource(createSource(//
"var v = <String, String> {'a' : 2};"));
resolve(source);
assertErrors(source, StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE);
verify(source);
}
public void test_mismatchedAccessorTypes_class() throws Exception {
Source source = addSource(createSource(//
"class A {",
" int get g { return 0; }",
" set g(String v) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES);
verify(source);
}
public void test_mismatchedAccessorTypes_getterAndSuperSetter() throws Exception {
Source source = addSource(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);
}
public void test_mismatchedAccessorTypes_setterAndSuperGetter() throws Exception {
Source source = addSource(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);
}
public void test_mismatchedAccessorTypes_topLevel() throws Exception {
Source source = addSource(createSource(//
"int get g { return 0; }",
"set g(String v) {}"));
resolve(source);
assertErrors(source, StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES);
verify(source);
}
public void test_mixedReturnTypes_localFunction() throws Exception {
Source source = addSource(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);
}
public void test_mixedReturnTypes_method() throws Exception {
Source source = addSource(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);
}
public void test_mixedReturnTypes_topLevelFunction() throws Exception {
Source source = addSource(createSource(//
"f(int x) {",
" if (x < 0) {",
" return;",
" }",
" return 0;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.MIXED_RETURN_TYPES, StaticWarningCode.MIXED_RETURN_TYPES);
verify(source);
}
public void test_newWithAbstractClass() throws Exception {
Source source = addSource(createSource(//
"abstract class A {}",
"void f() {",
" A a = new A();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NEW_WITH_ABSTRACT_CLASS);
verify(source);
}
public void test_newWithInvalidTypeParameters() throws Exception {
Source source = addSource(createSource(//
"class A {}",
"f() { return new A<A>(); }"));
resolve(source);
assertErrors(source, StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS);
verify(source);
}
public void test_newWithInvalidTypeParameters_tooFew() throws Exception {
Source source = addSource(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);
}
public void test_newWithInvalidTypeParameters_tooMany() throws Exception {
Source source = addSource(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);
}
public void test_newWithNonType() throws Exception {
Source source = addSource(createSource(//
"var A = 0;",
"void f() {",
" var a = new A();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NEW_WITH_NON_TYPE);
verify(source);
}
public void test_newWithNonType_fromLibrary() throws Exception {
Source source1 = addNamedSource("lib.dart", "class B {}");
Source source2 = addNamedSource("lib2.dart", 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);
}
public void test_newWithUndefinedConstructor() throws Exception {
Source source = addSource(createSource(//
"class A {",
" A() {}",
"}",
"f() {",
" new A.name();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR);
// no verify(), 'name' is not resolved
}
public void test_newWithUndefinedConstructorDefault() throws Exception {
Source source = addSource(createSource(//
"class A {",
" A.name() {}",
"}",
"f() {",
" new A();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT);
verify(source);
}
public void test_nonAbstractClassInheritsAbstractMemberFivePlus() throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberFour() throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface()
throws Exception {
// 15979
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin()
throws Exception {
// 15979
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass()
throws Exception {
// 15979
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation()
throws Exception {
// 15028
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface()
throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass()
throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface()
throws Exception {
Source source = addSource(createSource(//
"class I {",
" m(p) {}",
"}",
"class C implements I {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE);
verify(source);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass()
throws Exception {
Source source = addSource(createSource(//
"abstract class A {",
" m(p);",
"}",
"class C extends A {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE);
verify(source);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount()
throws Exception {
// 7640
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_getter()
throws Exception {
// 15001
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_method()
throws Exception {
// 15001
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_mixinInherits_setter()
throws Exception {
// 15001
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter()
throws Exception {
// test from language/override_inheritance_abstract_test_14.dart
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface()
throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass()
throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface()
throws Exception {
// bug 11154
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter()
throws Exception {
// 16133
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter()
throws Exception {
// 16133
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberThree() throws Exception {
Source source = addSource(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);
}
public void test_nonAbstractClassInheritsAbstractMemberTwo() throws Exception {
Source source = addSource(createSource(//
"abstract class A {",
" m();",
" n();",
"}",
"class C extends A {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO);
verify(source);
}
public void test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth()
throws Exception {
// 16133
Source source = addSource(createSource(//
"class I {",
" var v;",
"}",
"class C implements I {",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO);
verify(source);
}
public void test_nonTypeInCatchClause_noElement() throws Exception {
Source source = addSource(createSource(//
"f() {",
" try {",
" } on T catch (e) {",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE);
verify(source);
}
public void test_nonTypeInCatchClause_notType() throws Exception {
Source source = addSource(createSource(//
"var T = 0;",
"f() {",
" try {",
" } on T catch (e) {",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE);
verify(source);
}
public void test_nonVoidReturnForOperator() throws Exception {
Source source = addSource(createSource(//
"class A {",
" int operator []=(a, b) { return a; }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR);
verify(source);
}
public void test_nonVoidReturnForSetter_function() throws Exception {
Source source = addSource(createSource(//
"int set x(int v) {",
" return 42;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_VOID_RETURN_FOR_SETTER);
verify(source);
}
public void test_nonVoidReturnForSetter_method() throws Exception {
Source source = addSource(createSource(//
"class A {",
" int set x(int v) {",
" return 42;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NON_VOID_RETURN_FOR_SETTER);
verify(source);
}
public void test_notAType() throws Exception {
Source source = addSource(createSource(//
"f() {}",
"main() {",
" f v = null;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NOT_A_TYPE);
verify(source);
}
public void test_notEnoughRequiredArguments() throws Exception {
Source source = addSource(createSource(//
"f(int a, String b) {}",
"main() {",
" f();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
verify(source);
}
public void test_notEnoughRequiredArguments_functionExpression() throws Exception {
Source source = addSource(createSource(//
"main() {",
" (int x) {} ();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
verify(source);
}
public void test_notEnoughRequiredArguments_getterReturningFunction() throws Exception {
Source source = addSource(createSource(//
"typedef Getter(self);",
"Getter getter = (x) => x;",
"main() {",
" getter();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
verify(source);
}
public void test_partOfDifferentLibrary() throws Exception {
Source source = addSource(createSource(//
"library lib;",
"part 'part.dart';"));
addNamedSource("/part.dart", createSource(//
"part of lub;"));
resolve(source);
assertErrors(source, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY);
verify(source);
}
public void test_redirectToInvalidFunctionType() throws Exception {
Source source = addSource(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);
}
public void test_redirectToInvalidReturnType() throws Exception {
Source source = addSource(createSource(//
"class A {",
" A() {}",
"}",
"class B {",
" factory B() = A;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE);
verify(source);
}
public void test_redirectToMissingConstructor_named() throws Exception {
Source source = addSource(createSource(//
"class A implements B{",
" A() {}",
"}",
"class B {",
" factory B() = A.name;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
}
public void test_redirectToMissingConstructor_unnamed() throws Exception {
Source source = addSource(createSource(//
"class A implements B{",
" A.name() {}",
"}",
"class B {",
" factory B() = A;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
}
public void test_redirectToNonClass_notAType() throws Exception {
Source source = addSource(createSource(//
"class B {",
" int A;",
" factory B() = A;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.REDIRECT_TO_NON_CLASS);
verify(source);
}
public void test_redirectToNonClass_undefinedIdentifier() throws Exception {
Source source = addSource(createSource(//
"class B {",
" factory B() = A;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.REDIRECT_TO_NON_CLASS);
verify(source);
}
public void test_returnWithoutValue_factoryConstructor() throws Exception {
Source source = addSource(createSource(//
"class A { factory A() { return; } }"));
resolve(source);
assertErrors(source, StaticWarningCode.RETURN_WITHOUT_VALUE);
verify(source);
}
public void test_returnWithoutValue_function() throws Exception {
Source source = addSource(createSource(//
"int f() { return; }"));
resolve(source);
assertErrors(source, StaticWarningCode.RETURN_WITHOUT_VALUE);
verify(source);
}
public void test_returnWithoutValue_method() throws Exception {
Source source = addSource(createSource(//
"class A { int m() { return; } }"));
resolve(source);
assertErrors(source, StaticWarningCode.RETURN_WITHOUT_VALUE);
verify(source);
}
public void test_returnWithoutValue_mixedReturnTypes_function() throws Exception {
// Tests that only the RETURN_WITHOUT_VALUE warning is created, and no MIXED_RETURN_TYPES are
// created.
Source source = addSource(createSource(//
"int f(int x) {",
" if (x < 0) {",
" return 1;",
" }",
" return;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.RETURN_WITHOUT_VALUE);
verify(source);
}
public void test_staticAccessToInstanceMember_method_invocation() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m() {}",
"}",
"main() {",
" A.m();",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER);
verify(source);
}
public void test_staticAccessToInstanceMember_method_reference() throws Exception {
Source source = addSource(createSource(//
"class A {",
" m() {}",
"}",
"main() {",
" A.m;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER);
verify(source);
}
public void test_staticAccessToInstanceMember_propertyAccess_field() throws Exception {
Source source = addSource(createSource(//
"class A {",
" var f;",
"}",
"main() {",
" A.f;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER);
verify(source);
}
public void test_staticAccessToInstanceMember_propertyAccess_getter() throws Exception {
Source source = addSource(createSource(//
"class A {",
" get f => 42;",
"}",
"main() {",
" A.f;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER);
verify(source);
}
public void test_staticAccessToInstanceMember_propertyAccess_setter() throws Exception {
Source source = addSource(createSource(//
"class A {",
" set f(x) {}",
"}",
"main() {",
" A.f = 42;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER);
verify(source);
}
public void test_switchExpressionNotAssignable() throws Exception {
Source source = addSource(createSource(//
"f(int p) {",
" switch (p) {",
" case 'a': break;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE);
verify(source);
}
public void test_typeAnnotationDeferredClass_asExpression() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"f(var v) {",
" v as a.A;",
"}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_catchClause() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"f(var v) {",
" try {",
" } on a.A {",
" }",
"}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_fieldFormalParameter() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"class C {",
" var v;",
" C(a.A this.v);",
"}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_functionDeclaration_returnType() throws Exception {
resolve(
new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"a.A f() { return null; }")},
new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType()
throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"f(a.A g()) {}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_isExpression() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"f(var v) {",
" bool b = v is a.A;",
"}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_methodDeclaration_returnType() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"class C {",
" a.A m() { return null; }",
"}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_simpleFormalParameter() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"f(a.A v) {}")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_typeArgumentList() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"class C<E> {}",
"C<a.A> c;")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_typeArgumentList2() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"class C<E, F> {}",
"C<a.A, a.A> c;")}, new ErrorCode[] {
StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS,
StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_typeParameter_bound() throws Exception {
resolve(
new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"class C<E extends a.A> {}")},
new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeAnnotationDeferredClass_variableDeclarationList() throws Exception {
resolve(new String[] {createSource(//
"library lib1;",
"class A {}"),//
createSource(//
"library root;",
"import 'lib1.dart' deferred as a;",
"a.A v;")}, new ErrorCode[] {StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS});
}
public void test_typeParameterReferencedByStatic_field() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static K k;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typeParameterReferencedByStatic_getter() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static K get k => null;",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typeParameterReferencedByStatic_methodBodyReference() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static m() {",
" K k;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typeParameterReferencedByStatic_methodParameter() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static m(K k) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typeParameterReferencedByStatic_methodReturn() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static K m() { return null; }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typeParameterReferencedByStatic_setter() throws Exception {
Source source = addSource(createSource(//
"class A<K> {",
" static set s(K k) {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC);
verify(source);
}
public void test_typePromotion_functionType_arg_InterToDyn() throws Exception {
Source source = addSource(createSource(//
"typedef FuncDyn(x);",
"typedef FuncA(A a);",
"class A {}",
"class B {}",
"main(FuncA f) {",
" if (f is FuncDyn) {", // ignored: dynamic !<< A
" f(new B());",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
}
public void test_typeTestNonType() throws Exception {
Source source = addSource(createSource(//
"var A = 0;",
"f(var p) {",
" if (p is A) {",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.TYPE_TEST_NON_TYPE);
verify(source);
}
public void test_undefinedClass_instanceCreation() throws Exception {
Source source = addSource(createSource(//
"f() { new C(); }"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_CLASS);
}
public void test_undefinedClass_variableDeclaration() throws Exception {
Source source = addSource(createSource(//
"f() { C c; }"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_CLASS);
}
public void test_undefinedClassBoolean_variableDeclaration() throws Exception {
Source source = addSource(createSource(//
"f() { boolean v; }"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_CLASS_BOOLEAN);
}
public void test_undefinedGetter_fromLibrary() throws Exception {
Source source1 = addNamedSource("lib.dart", "");
Source source2 = addNamedSource("lib2.dart", createSource(//
"import 'lib.dart' as lib;",
"void f() {",
" var g = lib.gg;",
"}"));
resolve(source1);
resolve(source2);
assertErrors(source2, StaticWarningCode.UNDEFINED_GETTER);
verify(source1);
}
public void test_undefinedIdentifier_for() throws Exception {
Source source = addSource(createSource(//
"f(var l) {",
" for (e in l) {",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_function() throws Exception {
Source source = addSource(createSource(//
"int a() => b;"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_function_prefix() throws Exception {
addNamedSource("/lib.dart", createSource(//
"library lib;",
"class C {}"));
Source source = addSource(createSource(//
"import 'lib.dart' as b;",
"",
"int a() => b;",
"b.C c;"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
verify(source);
}
public void test_undefinedIdentifier_initializer() throws Exception {
Source source = addSource(createSource(//
"var a = b;"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_initializer_prefix() throws Exception {
addNamedSource("/lib.dart", createSource(//
"library lib;",
"class C {}"));
Source source = addSource(createSource(//
"import 'lib.dart' as b;",
"",
"var a = b;",
"b.C c;"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_methodInvocation() throws Exception {
Source source = addSource(createSource(//
"f() { C.m(); }"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_private_getter() throws Exception {
addNamedSource("/lib.dart", createSource(//
"library lib;",
"class A {",
" var _foo;",
"}"));
Source source = addSource(createSource(//
"import 'lib.dart';",
"class B extends A {",
" test() {",
" var v = _foo;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedIdentifier_private_setter() throws Exception {
addNamedSource("/lib.dart", createSource(//
"library lib;",
"class A {",
" var _foo;",
"}"));
Source source = addSource(createSource(//
"import 'lib.dart';",
"class B extends A {",
" test() {",
" _foo = 42;",
" }",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_IDENTIFIER);
}
public void test_undefinedNamedParameter() throws Exception {
Source source = addSource(createSource(//
"f({a, b}) {}",
"main() {",
" f(c: 1);",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.UNDEFINED_NAMED_PARAMETER);
// no verify(), 'c' is not resolved
}
public void test_undefinedSetter() throws Exception {
Source source1 = addNamedSource("lib.dart", "");
Source source2 = addNamedSource("lib2.dart", createSource(//
"import 'lib.dart' as lib;",
"void f() {",
" lib.gg = null;",
"}"));
resolve(source1);
resolve(source2);
assertErrors(source2, StaticWarningCode.UNDEFINED_SETTER);
}
// See comment on StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER
public void test_undefinedStaticMethodOrGetter_getter() throws Exception {
Source source = addSource(createSource(//
"class C {}",
"f(var p) {",
" f(C.m);",
"}"));
resolve(source);
assertErrors(source, StaticTypeWarningCode.UNDEFINED_GETTER);
}
// See comment on StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER
public void test_undefinedStaticMethodOrGetter_getter_inSuperclass() throws Exception {
Source source = addSource(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);
}
// See comment on StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER
public void test_undefinedStaticMethodOrGetter_method() throws Exception {
Source source = addSource(createSource(//
"class C {}",
"f(var p) {",
" f(C.m());",
"}"));
resolve(source);
assertErrors(source, StaticTypeWarningCode.UNDEFINED_METHOD);
}
// See comment on StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER
public void test_undefinedStaticMethodOrGetter_method_inSuperclass() throws Exception {
Source source = addSource(createSource(//
"class S {",
" static m() {}",
"}",
"class C extends S {}",
"f(var p) {",
" f(C.m());",
"}"));
resolve(source);
assertErrors(source, StaticTypeWarningCode.UNDEFINED_METHOD);
}
// See comment on StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER
public void test_undefinedStaticMethodOrGetter_setter_inSuperclass() throws Exception {
Source source = addSource(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);
}
public void test_voidReturnForGetter() throws Exception {
Source source = addSource(createSource(//
"class S {",
" void get value {}",
"}"));
resolve(source);
assertErrors(source, StaticWarningCode.VOID_RETURN_FOR_GETTER);
}
}