Removed fixed dependencies

packages/analyzer/test/generated/static_warning_code_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library engine.static_warning_code_test;
+library analyzer.test.generated.static_warning_code_test;
 
-import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
-import '../reflective_tests.dart';
 import '../utils.dart';
-import 'resolver_test.dart';
+import 'resolver_test_case.dart';
 
 main() {
   initializeTestEnvironment();
-  runReflectiveTests(StaticWarningCodeTest);
+  defineReflectiveTests(StaticWarningCodeTest);
 }
 
 @reflectiveTest
 class StaticWarningCodeTest extends ResolverTestCase {
+  void fail_argumentTypeNotAssignable_tearOff_required() {
+    Source source = addSource(r'''
+class C {
+  Object/*=T*/ f/*<T>*/(Object/*=T*/ x) => x;
+}
+g(C c) {
+  var h = c.f/*<int>*/;
+  print(h('s'));
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    verify([source]);
+  }
+
   void fail_undefinedGetter() {
     Source source = addSource(r'''
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source]);
   }
 
   void fail_undefinedIdentifier_commentReference() {
     Source source = addSource(r'''
@@ skipping 925 matching lines @@
     Source source = addSource(r'''
 class A {
   m();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
     verify([source]);
   }
 
+  void test_concreteClassWithAbstractMember_noSuchMethod_interface() {
+    Source source = addSource(r'''
+class I {
+  noSuchMethod(v) => '';
+}
+class A implements I {
+  m();
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(
+        source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
+    verify([source]);
+  }
+
   void test_conflictingDartImport() {
     Source source = addSource(r'''
 import 'lib.dart';
 import 'dart:async';
 Future f = null;
 Stream s;''');
     addNamedSource(
         "/lib.dart",
         r'''
 library lib;
 class Future {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
-  void test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() {
+  void
+      test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
 }
 class B extends A {
   var v;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
-  void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_getter() {
+  void
+      test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_getter() {
     Source source = addSource(r'''
 class A {
   static get v => 0;
 }
 class B extends A {
   get v => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
-  void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_method() {
+  void
+      test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_method() {
     Source source = addSource(r'''
 class A {
   static v() {}
 }
 class B extends A {
   get v => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
     verify([source]);
   }
 
-  void test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_setter() {
+  void
+      test_conflictingInstanceGetterAndSuperclassMember_declGetter_direct_setter() {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
 }
 class B extends A {
   get v => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
@@ skipping 1263 matching lines @@
   void test_mismatchedAccessorTypes_topLevel() {
     Source source = addSource(r'''
 int get g { return 0; }
 set g(String v) {}''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
 
+  void test_missingEnumConstantInSwitch() {
+    Source source = addSource(r'''
+enum E { ONE, TWO, THREE, FOUR }
+bool odd(E e) {
+  switch (e) {
+    case E.ONE:
+    case E.THREE: return true;
+  }
+  return false;
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [
+      StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
+      StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH
+    ]);
+    verify([source]);
+  }
+
   void test_mixedReturnTypes_localFunction() {
     Source source = addSource(r'''
 class C {
   m(int x) {
     return (int y) {
       if (y < 0) {
         return;
       }
       return 0;
     };
@@ skipping 166 matching lines @@
   p();
 }
 class C extends A {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
     // 15979
     Source source = addSource(r'''
 abstract class M {}
 abstract class A {}
 abstract class I {
   m();
 }
 class B = A with M implements I;''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin() {
     // 15979
     Source source = addSource(r'''
 abstract class M {
   m();
 }
 abstract class A {}
 class B = A with M;''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
     // 15979
     Source source = addSource(r'''
 class M {}
 abstract class A {
   m();
 }
 class B = A with M;''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
     // 15028
     Source source = addSource(r'''
 class C {
   foo(int x) => x;
 }
 abstract class D {
   foo(x, [y]);
 }
 class E extends C implements D {}''');
     computeLibrarySourceErrors(source);
@@ skipping 47 matching lines @@
   m(p);
 }
 class C extends A {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount() {
     // 7640
     Source source = addSource(r'''
 abstract class A {
   int x(int a);
 }
 abstract class B {
   int x(int a, [int b]);
 }
 class C implements A, B {
 }''');
@@ skipping 29 matching lines @@
     // 15001
     Source source = addSource(r'''
 abstract class A { set s1(v); set s2(v); }
 abstract class B implements A { set s1(v) {} }
 class C extends Object with B {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter() {
+  void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_interface() {
+    // 15979
+    Source source = addSource(r'''
+class I {
+  noSuchMethod(v) => '';
+}
+abstract class A {
+  m();
+}
+class B extends A implements I {
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
+
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_setter_and_implicitSetter() {
     // test from language/override_inheritance_abstract_test_14.dart
     Source source = addSource(r'''
 abstract class A {
   set field(_);
 }
 abstract class I {
   var field;
 }
 class B extends A implements I {
   get field => 0;
@@ skipping 40 matching lines @@
   get b => 'b';
 }
 class C extends B {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingGetter() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
   set v(_) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_variable_fromInterface_missingSetter() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
   get v => 1;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
@@ skipping 23 matching lines @@
   n();
 }
 class C extends A {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromInterface_missingBoth() {
     // 16133
     Source source = addSource(r'''
 class I {
   var v;
 }
 class C implements I {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
     verify([source]);
   }
 
+  void
+      test_nonAbstractClassInheritsAbstractMemberTwo_variable_fromMixin_missingBoth() {
+    // 26411
+    resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
+    Source source = addSource(r'''
+class A {
+  int f;
+}
+class B extends A {}
+class C extends Object with B {}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source,
+        [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO]);
+    verify([source]);
+  }
+
   void test_nonTypeInCatchClause_noElement() {
     Source source = addSource(r'''
 f() {
   try {
   } on T catch (e) {
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
     verify([source]);
@@ skipping 352 matching lines @@
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 a.A f() { return null; }'''
     ], <ErrorCode>[
       StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
     ]);
   }
 
-  void test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType() {
+  void
+      test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(a.A g()) {}'''
     ], <ErrorCode>[
       StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
@@ skipping 314 matching lines @@
 import 'lib.dart';
 class B extends A {
   test() {
     _foo = 42;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
+  void test_undefinedIdentifierAwait_function() {
+    Source source = addSource("void a() { await; }");
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER_AWAIT]);
+  }
+
   void test_undefinedNamedParameter() {
     Source source = addSource(r'''
 f({a, b}) {}
 main() {
   f(c: 1);
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
     // no verify(), 'c' is not resolved
   }
@@ skipping 73 matching lines @@
 
   void test_voidReturnForGetter() {
     Source source = addSource(r'''
 class S {
   void get value {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }