Enable enum and deferred import support

pkg/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;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart' as _ut;
@@ skipping 176 matching lines @@
     Source source = addSource(r'''
 f() {
   yield 0;
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR]);
     verify([source]);
   }
 
   void test_accessPrivateEnumField() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 String name(E e) {
   return e._name;
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD]);
     // Cannot verify because "_name" cannot be resolved.
   }
 
@@ skipping 424 matching lines @@
   const A();
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
     verify([source]);
   }
 
   void test_constDeferredClass() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {
   const A();
 }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A();
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
   }
 
   void test_constDeferredClass_namedConstructor() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {
   const A.b();
 }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A.b();
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
   }
 
   void test_constEval_newInstance_constConstructor() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 const a = new A();''');
     resolve(source);
@@ skipping 181 matching lines @@
   void test_constInitializedWithNonConstValue_missingConstInMapLiteral() {
     Source source = addSource("const Map M = {'a' : 0};");
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
 
   void test_constInitializedWithNonConstValueFromDeferredClass() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const V = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 const B = a.V;'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_constInitializedWithNonConstValueFromDeferredClass_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const V = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 const B = a.V + 1;'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_constInstanceField() {
     Source source = addSource(r'''
 class C {
   const int f = 0;
 }''');
     resolve(source);
@@ skipping 511 matching lines @@
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';''');
     addNamedSource("/lib1.dart", "part of lib;");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
 
   void test_extendsDeferredClass() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B extends a.A {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
   }
 
   void test_extendsDeferredClass_classTypeAlias() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class M {}
 class C = a.A with M;'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
   }
 
   void test_extendsDisallowedClass_class_bool() {
     Source source = addSource("class A extends bool {}");
     resolve(source);
     assertErrors(
         source,
         [
             CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ skipping 116 matching lines @@
     resolve(source);
     assertErrors(
         source,
         [
             CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
             CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
     verify([source]);
   }
 
   void test_extendsEnum() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 class A extends E {}''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.EXTENDS_ENUM]);
     verify([source]);
   }
 
   void test_extendsNonClass_class() {
     Source source = addSource(r'''
@@ skipping 289 matching lines @@
   get x => 0;
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
     verify([source]);
   }
 
   void test_implementsDeferredClass() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B implements a.A {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
   }
 
   void test_implementsDeferredClass_classTypeAlias() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B {}
 class M {}
 class C = B with M implements a.A;'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
   }
 
   void test_implementsDisallowedClass_class_bool() {
     Source source = addSource("class A implements bool {}");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
@@ skipping 118 matching lines @@
   }
 
   void test_implementsDynamic() {
     Source source = addSource("class A implements dynamic {}");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]);
     verify([source]);
   }
 
   void test_implementsEnum() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 class A implements E {}''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_ENUM]);
     verify([source]);
   }
 
   void test_implementsNonClass_class() {
     Source source = addSource(r'''
@@ skipping 421 matching lines @@
   }
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
     verify([source]);
   }
 
   void test_instantiateEnum_const() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 E e(String name) {
   return const E();
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INSTANTIATE_ENUM]);
     verify([source]);
   }
 
   void test_instantiateEnum_new() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 E e(String name) {
   return new E();
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INSTANTIATE_ENUM]);
     verify([source]);
   }
 
@@ skipping 119 matching lines @@
 @foo
 class A {
   static const foo = null;
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
   }
 
   void test_invalidAnnotationFromDeferredLibrary() {
     // See test_invalidAnnotation_notConstantVariable
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class V { const V(); }
 const v = const V();''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 @a.v main () {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_invalidAnnotationFromDeferredLibrary_constructor() {
     // See test_invalidAnnotation_notConstantVariable
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class C { const C(); }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 @a.C() main () {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_invalidAnnotationFromDeferredLibrary_namedConstructor() {
     // See test_invalidAnnotation_notConstantVariable
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class C { const C.name(); }''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 @a.C.name() main () {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_invalidConstructorName_notEnclosingClassName_defined() {
     Source source = addSource(r'''
 class A {
   B() : super();
 }
 class B {}''');
     resolve(source);
@@ skipping 369 matching lines @@
   x(y) {}
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
     verify([source]);
   }
 
   void test_missingEnumConstantInSwitch() {
-    resetWithEnum();
     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;
 }''');
     resolve(source);
@@ skipping 21 matching lines @@
 class A {
   A() {}
 }
 class B = Object with A;''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
 
   void test_mixinDeferredClass() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B extends Object with a.A {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
   }
 
   void test_mixinDeferredClass_classTypeAlias() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 class A {}''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B {}
 class C = B with a.A;'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
   }
 
   void test_mixinHasNoConstructors_mixinApp() {
     Source source = addSource(r'''
 class B {
   B({x});
 }
 class M {}
 class C = B with M;
@@ skipping 220 matching lines @@
     resolve(source);
     assertErrors(
         source,
         [
             CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS,
             CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_mixinOfEnum() {
-    resetWithEnum();
     Source source = addSource(r'''
 enum E { ONE }
 class A extends Object with E {}''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_ENUM]);
     verify([source]);
   }
 
   void test_mixinOfNonClass_class() {
     Source source = addSource(r'''
@@ skipping 466 matching lines @@
 class A {
   int y;
   m([x = y]) {}
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
 
   void test_nonConstantDefaultValueFromDeferredLibrary() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const V = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f({x : a.V}) {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstantDefaultValueFromDeferredLibrary_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const V = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f({x : a.V + 1}) {}'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstCaseExpression() {
     Source source = addSource(r'''
 f(int p, int q) {
   switch (p) {
     case 3 + q:
       break;
   }
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
     verify([source]);
   }
 
   void test_nonConstCaseExpressionFromDeferredLibrary() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main (int p) {
   switch (p) {
     case a.c:
       break;
   }
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstCaseExpressionFromDeferredLibrary_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 main (int p) {
   switch (p) {
     case a.c + 1:
       break;
   }
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstListElement() {
     Source source = addSource(r'''
 f(a) {
   return const [a];
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
     verify([source]);
   }
 
   void test_nonConstListElementFromDeferredLibrary() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const [a.c];
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstListElementFromDeferredLibrary_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const [a.c + 1];
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstMapAsExpressionStatement_begin() {
     Source source = addSource(r'''
 f() {
   {'a' : 0, 'b' : 1}.length;
 }''');
     resolve(source);
@@ skipping 19 matching lines @@
     Source source = addSource(r'''
 f(a) {
   return const {a : 0};
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]);
     verify([source]);
   }
 
   void test_nonConstMapKeyFromDeferredLibrary() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const {a.c : 0};
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstMapKeyFromDeferredLibrary_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const {a.c + 1 : 0};
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstMapValue() {
     Source source = addSource(r'''
 f(a) {
   return const {'a' : a};
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
     verify([source]);
   }
 
   void test_nonConstMapValueFromDeferredLibrary() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const {'a' : a.c};
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstMapValueFromDeferredLibrary_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 const int c = 1;''', r'''
 library root;
 import 'lib1.dart' deferred as a;
 f() {
   return const {'a' : a.c + 1};
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstValueInInitializer_binary_notBool_left() {
     Source source = addSource(r'''
 class A {
   final bool a;
   const A(String p) : a = p && true;
 }''');
     resolve(source);
@@ skipping 105 matching lines @@
   const B() : super(C);
 }''');
     resolve(source);
     assertErrors(
         source,
         [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
     verify([source]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_field() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    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;
 }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_field_nested() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    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>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_redirecting() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    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>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonConstValueInInitializerFromDeferredLibrary_super() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    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>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[
               CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
   }
 
   void test_nonGenerativeConstructor_explicit() {
     Source source = addSource(r'''
 class A {
   factory A.named() {}
 }
 class B extends A {
@@ skipping 625 matching lines @@
     Source source = addSource(r'''
 f() sync* {
   return 0;
 }''');
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATOR]);
     verify([source]);
   }
 
   void test_sharedDeferredPrefix() {
-    resolveWithAndWithoutExperimental(<String>[r'''
+    resolveWithErrors(<String>[r'''
 library lib1;
 f1() {}''', r'''
 library lib2;
 f2() {}''', r'''
 library root;
 import 'lib1.dart' deferred as lib;
 import 'lib2.dart' as lib;
 main() { lib.f1(); lib.f2(); }'''],
-          <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED],
           <ErrorCode>[CompileTimeErrorCode.SHARED_DEFERRED_PREFIX]);
   }
 
   void test_superInInvalidContext_binaryExpression() {
     Source source = addSource("var v = super + 0;");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
     // no verify(), 'super.v' is not resolved
   }
 
@@ skipping 556 matching lines @@
         [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }