Removed fixed dependencies

packages/analyzer/test/generated/compile_time_error_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.compile_time_error_code_test;
+library analyzer.test.generated.compile_time_error_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/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'package:unittest/unittest.dart' show expect;
 
-import '../reflective_tests.dart';
 import '../utils.dart';
-import 'resolver_test.dart';
+import 'resolver_test_case.dart';
 
 main() {
   initializeTestEnvironment();
-  runReflectiveTests(CompileTimeErrorCodeTest);
+  defineReflectiveTests(CompileTimeErrorCodeTest);
 }
 
 @reflectiveTest
 class CompileTimeErrorCodeTest extends ResolverTestCase {
   void fail_awaitInWrongContext_sync() {
     // This test requires better error recovery than we currently have. In
     // particular, we need to be able to distinguish between an await expression
     // in the wrong context, and the use of 'await' as an identifier.
     Source source = addSource(r'''
 f(x) {
@@ skipping 187 matching lines @@
     addNamedSource(
         "/lib2.dart",
         r'''
 library lib2;
 class N {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
 
+  void test_annotationWithNotClass() {
+    Source source = addSource('''
+class Property {
+  final int value;
+  const Property(this.value);
+}
+
+const Property property = const Property(42);
+
+@property(123)
+main() {
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.ANNOTATION_WITH_NON_CLASS]);
+    verify([source]);
+  }
+
+  void test_annotationWithNotClass_prefixed() {
+    addNamedSource(
+        "/annotations.dart",
+        r'''
+class Property {
+  final int value;
+  const Property(this.value);
+}
+
+const Property property = const Property(42);
+''');
+    Source source = addSource('''
+import 'annotations.dart' as pref;
+@pref.property(123)
+main() {
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.ANNOTATION_WITH_NON_CLASS]);
+    verify([source]);
+  }
+
+  void test_assertWithExtraArgument() {
+    // TODO(paulberry): once DEP 37 is turned on by default, this test should
+    // be removed.
+    Source source = addSource('''
+f(bool x) {
+  assert(x, 'foo');
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.EXTRA_ARGUMENT_TO_ASSERT]);
+    verify([source]);
+  }
+
   void test_async_used_as_identifier_in_annotation() {
     Source source = addSource('''
 const int async = 0;
 f() async {
   g(@async x) {}
   g(0);
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
@@ skipping 602 matching lines @@
   final int i = f();
   const A();
 }
 int f() {
   return 3;
 }''');
     computeLibrarySourceErrors(source);
     // TODO(paulberry): the error CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE is
     // redundant and ought to be suppressed.
     assertErrors(source, [
-      CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
+      CompileTimeErrorCode
+          .CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
       CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
     ]);
     verify([source]);
   }
 
   void test_constConstructorWithFieldInitializedByNonConst_static() {
     Source source = addSource(r'''
 class A {
   static final int i = f();
   const A();
@@ skipping 144 matching lines @@
     Source source = addSource(r'''
 class A {
   external factory const A();
 }
 const x = const A();''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_constEval_nonStaticField_inGenericClass() {
+    Source source = addSource('''
+class C<T> {
+  const C();
+  T get t => null;
+}
+
+const x = const C().t;''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    verify([source]);
+  }
+
   void test_constEval_propertyExtraction_targetNotConst() {
     Source source = addSource(r'''
 class A {
   const A();
   m() {}
 }
 final a = const A();
 const C = a.m;''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
@@ skipping 169 matching lines @@
     Source source = addSource(r'''
 f(p) {
   const C = p;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
+  void test_constInitializedWithNonConstValue_finalField() {
+    // Regression test for bug #25526 which previously
+    // caused two errors to be reported.
+    Source source = addSource(r'''
+class Foo {
+  final field = [];
+  foo([int x = field]) {}
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
+    verify([source]);
+  }
+
   void test_constInitializedWithNonConstValue_missingConstInListLiteral() {
     Source source = addSource("const List L = [0];");
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValue_missingConstInMapLiteral() {
     Source source = addSource("const Map M = {'a' : 0};");
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValueFromDeferredClass() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const V = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 const B = a.V;'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_constInitializedWithNonConstValueFromDeferredClass_nested() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const V = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 const B = a.V + 1;'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_constInstanceField() {
     Source source = addSource(r'''
 class C {
   const int f = 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
@@ skipping 119 matching lines @@
     Source source = addSource(r'''
 class T {
   T(a, b, {c, d}) {}
 }
 f() { return const T(0, 1, c: 2, d: 3); }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONST]);
     verify([source]);
   }
 
+  void test_constWithNonConst_with() {
+    Source source = addSource(r'''
+class B {
+  const B();
+}
+class C = B with M;
+class M {}
+const x = const C();
+main() {
+  print(x);
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONST]);
+    verify([source]);
+  }
+
   void test_constWithNonConstantArgument_annotation() {
     Source source = addSource(r'''
 class A {
   const A(int p);
 }
 var v = 42;
 @A(v)
 main() {
 }''');
     computeLibrarySourceErrors(source);
@@ skipping 183 matching lines @@
 
 class A {}''');
     Source sourceB = addNamedSource(
         "/b.dart",
         r'''
 part of lib;
 
 class A {}''');
     computeLibrarySourceErrors(librarySource);
     assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertNoErrors(librarySource);
     verify([librarySource, sourceA, sourceB]);
   }
 
   void test_duplicateDefinition_catch() {
     Source source = addSource(r'''
 main() {
   try {} catch (e, e) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
@@ skipping 26 matching lines @@
     Source source = addSource(r'''
 class A {
   m() {}
   m() {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
 
+  void test_duplicateDefinition_inPart() {
+    Source librarySource = addNamedSource(
+        "/lib.dart",
+        r'''
+library test;
+part 'a.dart';
+class A {}''');
+    Source sourceA = addNamedSource(
+        "/a.dart",
+        r'''
+part of test;
+class A {}''');
+    computeLibrarySourceErrors(librarySource);
+    assertErrors(sourceA, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertNoErrors(librarySource);
+    verify([librarySource, sourceA]);
+  }
+
   void test_duplicateDefinition_locals_inCase() {
     Source source = addSource(r'''
 main() {
   switch(1) {
     case 1:
       var a;
       var a;
   }
 }''');
     computeLibrarySourceErrors(source);
@@ skipping 31 matching lines @@
   m() {
     int a;
     int a;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
 
+  void test_duplicateDefinition_parameters_inConstructor() {
+    Source source = addSource(r'''
+class A {
+  int a;
+  A(int a, this.a);
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    verify([source]);
+  }
+
   void test_duplicateDefinition_parameters_inFunctionTypeAlias() {
     Source source = addSource(r'''
 typedef F(int a, double a);
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
 
   void test_duplicateDefinition_parameters_inLocalFunction() {
@@ skipping 43 matching lines @@
 }
 class B extends A {
   static int get x => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
 
-  void test_duplicateDefinitionInheritance_instanceGetterAbstract_staticGetter() {
+  void
+      test_duplicateDefinitionInheritance_instanceGetterAbstract_staticGetter() {
     Source source = addSource(r'''
 abstract class A {
   int get x;
 }
 class B extends A {
   static int get x => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
 
   void test_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
     Source source = addSource(r'''
 class A {
   x() {}
 }
 class B extends A {
   static x() {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
 
-  void test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
+  void
+      test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
     Source source = addSource(r'''
 abstract class A {
   x();
 }
 abstract class B extends A {
   static x() {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
 
   void test_duplicateDefinitionInheritance_instanceSetter_staticSetter() {
     Source source = addSource(r'''
 class A {
   set x(value) {}
 }
 class B extends A {
   static set x(value) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
     verify([source]);
   }
 
-  void test_duplicateDefinitionInheritance_instanceSetterAbstract_staticSetter() {
+  void
+      test_duplicateDefinitionInheritance_instanceSetterAbstract_staticSetter() {
     Source source = addSource(r'''
 abstract class A {
   set x(value);
 }
 class B extends A {
   static set x(value) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
@@ skipping 63 matching lines @@
     assertErrors(source, [
       CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
       CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
     ]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_class_double() {
     Source source = addSource("class A extends double {}");
     computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
-      CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
-    ]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_class_int() {
     Source source = addSource("class A extends int {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
       CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
     ]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_class_Null() {
     Source source = addSource("class A extends Null {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
       CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
     ]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_class_num() {
     Source source = addSource("class A extends num {}");
     computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
-      CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
-    ]);
+    assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_extendsDisallowedClass_class_String() {
     Source source = addSource("class A extends String {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
       CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
     ]);
@@ skipping 98 matching lines @@
   const A();
 }
 class B extends A {
   const B() : super(0);
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
 
+  void test_fieldFormalParameter_assignedInInitializer() {
+    Source source = addSource(r'''
+class A {
+  int x;
+  A(this.x) : x = 3 {}
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
+    verify([source]);
+  }
+
   void test_fieldInitializedByMultipleInitializers() {
     Source source = addSource(r'''
 class A {
   int x;
   A() : x = 0, x = 1 {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
@@ skipping 37 matching lines @@
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
     verify([source]);
   }
 
   void test_fieldInitializerFactoryConstructor() {
     Source source = addSource(r'''
 class A {
   int x;
-  factory A(this.x) {}
+  factory A(this.x) => null;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_fieldInitializerOutsideConstructor() {
     // TODO(brianwilkerson) Fix the duplicate error messages.
     Source source = addSource(r'''
@@ skipping 14 matching lines @@
 class A {
   int x;
   m([this.x]) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
     verify([source]);
   }
 
+  void test_fieldInitializerOutsideConstructor_inFunctionTypeParameter() {
+    Source source = addSource(r'''
+class A {
+  int x;
+  A(int p(this.x));
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(
+        source, [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
+    verify([source]);
+  }
+
   void test_fieldInitializerRedirectingConstructor_afterRedirection() {
     Source source = addSource(r'''
 class A {
   int x;
   A.named() {}
   A() : this.named(), x = 42;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
         [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
@@ skipping 58 matching lines @@
     verify([source]);
   }
 
   void test_finalInitializedMultipleTimes_initializingFormals() {
     Source source = addSource(r'''
 class A {
   final x;
   A(this.x, this.x) {}
 }''');
     computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES]);
+    // TODO(brianwilkerson) There should only be one error here.
+    assertErrors(source, [
+      CompileTimeErrorCode.DUPLICATE_DEFINITION,
+      CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES
+    ]);
     verify([source]);
   }
 
   void test_finalNotInitialized_instanceField_const_static() {
     Source source = addSource(r'''
 class A {
   static const F;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
@@ skipping 329 matching lines @@
 class A {
   static var F = m();
   m() {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
 
-  void test_implicitThisReferenceInInitializer_redirectingConstructorInvocation() {
+  void
+      test_implicitThisReferenceInInitializer_redirectingConstructorInvocation() {
     Source source = addSource(r'''
 class A {
   A(p) {}
   A.named() : this(f);
   var f;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
@@ skipping 345 matching lines @@
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
-  void test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() {
+  void
+      test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() {
     addNamedSource(
         "/lib.dart",
         r'''
 library lib;
 typedef V();''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
@@ skipping 139 matching lines @@
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
     // no verify() call, "B" is not resolved
   }
 
   void test_invalidFactoryNameNotAClass_notClassName() {
     Source source = addSource(r'''
 int B;
 class A {
-  factory B() {}
+  factory B() => null;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
     verify([source]);
   }
 
   void test_invalidFactoryNameNotAClass_notEnclosingClassName() {
     Source source = addSource(r'''
 class A {
-  factory B() {}
+  factory B() => null;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
     // no verify() call, "B" is not resolved
   }
 
   void test_invalidModifierOnConstructor_async() {
     Source source = addSource(r'''
 class A {
@@ skipping 333 matching lines @@
 class A {
   get x => 0;
   x(y) {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
     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, [
-      CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
-      CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH
-    ]);
-    verify([source]);
-  }
-
   void test_mixinDeclaresConstructor_classDeclaration() {
     Source source = addSource(r'''
 class A {
   A() {}
 }
 class B extends Object with A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
@@ skipping 1086 matching lines @@
 library lib1;
 const int c = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class A {
   final int x;
   const A() : x = a.c;
 }'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_field_nested() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const int c = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class A {
   final int x;
   const A() : x = a.c + 1;
 }'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_redirecting() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const int c = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class A {
   const A.named(p);
   const A() : this.named(a.c);
 }'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_super() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 const int c = 1;''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class A {
   const A(p);
 }
 class B extends A {
   const B() : super(a.c);
 }'''
     ], <ErrorCode>[
-      CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
+      CompileTimeErrorCode
+          .NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY
     ]);
   }
 
   void test_nonGenerativeConstructor_explicit() {
     Source source = addSource(r'''
 class A {
-  factory A.named() {}
+  factory A.named() => null;
 }
 class B extends A {
   B() : super.named();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_nonGenerativeConstructor_implicit() {
     Source source = addSource(r'''
 class A {
-  factory A() {}
+  factory A() => null;
 }
 class B extends A {
   B();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_nonGenerativeConstructor_implicit2() {
     Source source = addSource(r'''
 class A {
-  factory A() {}
+  factory A() => null;
 }
 class B extends A {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_notEnoughRequiredArguments_const() {
     Source source = addSource(r'''
@@ skipping 695 matching lines @@
 
   void test_recursiveInterfaceInheritanceBaseCaseExtends() {
     Source source = addSource("class A extends A {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
     ]);
     verify([source]);
   }
 
+  void test_recursiveInterfaceInheritanceBaseCaseExtends_abstract() {
+    Source source = addSource(r'''
+class C extends C {
+  var bar = 0;
+  m();
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [
+      CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS,
+      StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
+      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
+    ]);
+    verify([source]);
+  }
+
   void test_recursiveInterfaceInheritanceBaseCaseImplements() {
     Source source = addSource("class A implements A {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
     ]);
     verify([source]);
   }
 
   void test_recursiveInterfaceInheritanceBaseCaseImplements_typeAlias() {
@@ skipping 147 matching lines @@
 
   void test_referencedBeforeDeclaration_inInitializer_directly() {
     Source source = addSource(r'''
 main() {
   var v = v;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
   }
 
+  void test_referencedBeforeDeclaration_type_localFunction() {
+    Source source = addSource(r'''
+void testTypeRef() {
+  String s = '';
+  int String(int x) => x + 1;
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
+  }
+
+  void test_referencedBeforeDeclaration_type_localVariable() {
+    Source source = addSource(r'''
+void testTypeRef() {
+  String s = '';
+  var String = '';
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
+  }
+
   void test_rethrowOutsideCatch() {
     Source source = addSource(r'''
 f() {
   rethrow;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
     verify([source]);
   }
 
@@ skipping 79 matching lines @@
   }
 
   void test_superInInvalidContext_factoryConstructor() {
     Source source = addSource(r'''
 class A {
   m() {}
 }
 class B extends A {
   factory B() {
     super.m();
+    return null;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
     // no verify(), 'super.m' is not resolved
   }
 
   void test_superInInvalidContext_instanceVariableInitializer() {
     Source source = addSource(r'''
 class A {
@@ skipping 281 matching lines @@
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
   void test_uriDoesNotExist_import() {
     Source source = addSource("import 'unknown.dart';");
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
+  void test_uriDoesNotExist_import_appears_after_deleting_target() {
+    Source test = addSource("import 'target.dart';");
+    Source target = addNamedSource("/target.dart", "");
+    computeLibrarySourceErrors(test);
+    assertErrors(test, [HintCode.UNUSED_IMPORT]);
+
+    // Remove the overlay in the same way as AnalysisServer.
+    analysisContext2.setContents(target, null);
+    ChangeSet changeSet = new ChangeSet()..removedSource(target);
+    analysisContext2.applyChanges(changeSet);
+
+    computeLibrarySourceErrors(test);
+    assertErrors(test, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+  }
+
+  void test_uriDoesNotExist_import_disappears_when_fixed() {
+    Source source = addSource("import 'target.dart';");
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+
+    // Check that the file is represented as missing.
+    Source target =
+        analysisContext2.getSourcesWithFullName("/target.dart").first;
+    expect(analysisContext2.getModificationStamp(target), -1);
+
+    // Add an overlay in the same way as AnalysisServer.
+    analysisContext2
+      ..setContents(target, "")
+      ..handleContentsChanged(target, null, "", true);
+
+    // Make sure the error goes away.
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNUSED_IMPORT]);
+  }
+
   void test_uriDoesNotExist_part() {
     Source source = addSource(r'''
 library lib;
 part 'unknown.dart';''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
   void test_uriWithInterpolation_constant() {
     Source source = addSource("import 'stuff_\$platform.dart';");
@@ skipping 228 matching lines @@
         source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }