diff --git a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart
index a21ef51..2a3d968 100644
--- a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart
+++ b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart
@@ -1,14 +1,19 @@
-// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'checked_mode_compile_time_error_code_test.dart';
+import 'resolver_test_case.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(CheckedModeCompileTimeErrorCodeTest_Driver);
+    defineReflectiveTests(SetElementTypeNotAssignableTest);
   });
 }
 
@@ -17,8 +22,24 @@
     extends CheckedModeCompileTimeErrorCodeTest {
   @override
   bool get enableNewAnalysisDriver => true;
+}
 
-  test_setElementTypeNotAssignable() async {
-    await super.test_setElementTypeNotAssignable();
+@reflectiveTest
+class SetElementTypeNotAssignableTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_simple() async {
+    Source source = addSource("var v = const <String>{42};");
+    await computeAnalysisResult(source);
+    // TODO(brianwilkerson) Fix this so that only one error is produced.
+    assertErrors(source, [
+      CheckedModeCompileTimeErrorCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE,
+      StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE
+    ]);
+    verify([source]);
   }
 }
diff --git a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
index 52ed142..6bfb23d 100644
--- a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
@@ -637,17 +637,6 @@
     verify([source]);
   }
 
-  @failingTest
-  test_setElementTypeNotAssignable() async {
-    Source source = addSource("var v = const <String>{42};");
-    await computeAnalysisResult(source);
-    assertErrors(source, [
-      CheckedModeCompileTimeErrorCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE,
-      StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE
-    ]);
-    verify([source]);
-  }
-
   test_superConstructor_paramTypeMismatch() async {
     Source source = addSource(r'''
 class C {
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
index c8acd25..9ff1460 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
@@ -1,14 +1,22 @@
-// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'compile_time_error_code_test.dart';
+import 'resolver_test_case.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(CompileTimeErrorCodeTest_Driver);
+    defineReflectiveTests(ConstSetElementTypeImplementsEqualsTest);
+    defineReflectiveTests(InvalidTypeArgumentInConstSetTest);
+    defineReflectiveTests(NonConstSetElementFromDeferredLibraryTest);
+    defineReflectiveTests(NonConstSetElementTest);
   });
 }
 
@@ -89,3 +97,188 @@
     return super.test_yieldInNonGenerator_sync();
   }
 }
+
+@reflectiveTest
+class ConstSetElementTypeImplementsEqualsTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_constField() async {
+    Source source = addSource(r'''
+class A {
+  static const a = const A();
+  const A();
+  operator ==(other) => false;
+}
+main() {
+  const {A.a};
+}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  test_direct() async {
+    Source source = addSource(r'''
+class A {
+  const A();
+  operator ==(other) => false;
+}
+main() {
+  const {const A()};
+}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  test_dynamic() async {
+    // Note: static type of B.a is "dynamic", but actual type of the const
+    // object is A.  We need to make sure we examine the actual type when
+    // deciding whether there is a problem with operator==.
+    Source source = addSource(r'''
+class A {
+  const A();
+  operator ==(other) => false;
+}
+class B {
+  static const a = const A();
+}
+main() {
+  const {B.a};
+}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  test_factory() async {
+    Source source = addSource(r'''
+class A { const factory A() = B; }
+
+class B implements A {
+  const B();
+
+  operator ==(o) => true;
+}
+
+main() {
+  var m = const {const A()};
+}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  test_super() async {
+    Source source = addSource(r'''
+class A {
+  const A();
+  operator ==(other) => false;
+}
+class B extends A {
+  const B();
+}
+main() {
+  const {const B()};
+}
+''');
+    await computeAnalysisResult(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+}
+
+@reflectiveTest
+class InvalidTypeArgumentInConstSetTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_class() async {
+    Source source = addSource(r'''
+class A<E> {
+  m() {
+    return const <E>{};
+  }
+}''');
+    await computeAnalysisResult(source);
+    assertErrors(
+        source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_SET]);
+    verify([source]);
+  }
+}
+
+@reflectiveTest
+class NonConstSetElementFromDeferredLibraryTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_topLevelVariable_immediate() async {
+    await resolveWithErrors(<String>[
+      r'''
+library lib1;
+const int c = 1;''',
+      r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+  return const {a.c};
+}'''
+    ], [
+      CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT_FROM_DEFERRED_LIBRARY
+    ]);
+  }
+
+  test_topLevelVariable_nested() async {
+    await resolveWithErrors(<String>[
+      r'''
+library lib1;
+const int c = 1;''',
+      r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+  return const {a.c + 1};
+}'''
+    ], [
+      CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT_FROM_DEFERRED_LIBRARY
+    ]);
+  }
+}
+
+@reflectiveTest
+class NonConstSetElementTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_parameter() async {
+    Source source = addSource(r'''
+f(a) {
+  return const {a};
+}''');
+    await computeAnalysisResult(source);
+    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT]);
+    verify([source]);
+  }
+}
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
index 1a74c98..8ecb71f 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
@@ -38,36 +38,6 @@
 
   @override
   @failingTest
-  test_constSetElementTypeImplementsEquals_constField() async {
-    return super.test_constSetElementTypeImplementsEquals_constField();
-  }
-
-  @override
-  @failingTest
-  test_constSetElementTypeImplementsEquals_direct() async {
-    return super.test_constSetElementTypeImplementsEquals_direct();
-  }
-
-  @override
-  @failingTest
-  test_constSetElementTypeImplementsEquals_dynamic() async {
-    return super.test_constSetElementTypeImplementsEquals_dynamic();
-  }
-
-  @override
-  @failingTest
-  test_constSetElementTypeImplementsEquals_factory() async {
-    return super.test_constSetElementTypeImplementsEquals_factory();
-  }
-
-  @override
-  @failingTest
-  test_constSetElementTypeImplementsEquals_super() async {
-    return super.test_constSetElementTypeImplementsEquals_super();
-  }
-
-  @override
-  @failingTest
   test_invalidIdentifierInAsync_async() {
     return super.test_invalidIdentifierInAsync_async();
   }
@@ -85,12 +55,6 @@
   }
 
   @override
-  @failingTest
-  test_invalidTypeArgumentInConstSet() async {
-    return super.test_invalidTypeArgumentInConstSet();
-  }
-
-  @override
   @failingTest // Does not work with old task model
   test_mixinInference_recursiveSubtypeCheck_new_syntax() {
     return super.test_mixinInference_recursiveSubtypeCheck_new_syntax();
@@ -104,24 +68,6 @@
 
   @override
   @failingTest
-  test_nonConstSetElement() async {
-    return super.test_nonConstSetElement();
-  }
-
-  @override
-  @failingTest
-  test_nonConstSetElementFromDeferredLibrary() async {
-    return super.test_nonConstSetElementFromDeferredLibrary();
-  }
-
-  @override
-  @failingTest
-  test_nonConstSetElementFromDeferredLibrary_nested() async {
-    return super.test_nonConstSetElementFromDeferredLibrary_nested();
-  }
-
-  @override
-  @failingTest
   test_objectCannotExtendAnotherClass() {
     return super.test_objectCannotExtendAnotherClass();
   }
@@ -1487,100 +1433,6 @@
     verify([source]);
   }
 
-  test_constSetElementTypeImplementsEquals_constField() async {
-    Source source = addSource(r'''
-class A {
-  static const a = const A();
-  const A();
-  operator ==(other) => false;
-}
-main() {
-  const {A.a};
-}
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source,
-        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
-
-  test_constSetElementTypeImplementsEquals_direct() async {
-    Source source = addSource(r'''
-class A {
-  const A();
-  operator ==(other) => false;
-}
-main() {
-  const {const A()};
-}
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source,
-        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
-
-  test_constSetElementTypeImplementsEquals_dynamic() async {
-    // Note: static type of B.a is "dynamic", but actual type of the const
-    // object is A.  We need to make sure we examine the actual type when
-    // deciding whether there is a problem with operator==.
-    Source source = addSource(r'''
-class A {
-  const A();
-  operator ==(other) => false;
-}
-class B {
-  static const a = const A();
-}
-main() {
-  const {B.a};
-}
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source,
-        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
-
-  test_constSetElementTypeImplementsEquals_factory() async {
-    Source source = addSource(r'''
-class A { const factory A() = B; }
-
-class B implements A {
-  const B();
-
-  operator ==(o) => true;
-}
-
-main() {
-  var m = const {const A()};
-}
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source,
-        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
-
-  test_constSetElementTypeImplementsEquals_super() async {
-    Source source = addSource(r'''
-class A {
-  const A();
-  operator ==(other) => false;
-}
-class B extends A {
-  const B();
-}
-main() {
-  const {const B()};
-}
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source,
-        [CompileTimeErrorCode.CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS]);
-    verify([source]);
-  }
-
   test_constWithInvalidTypeParameters() async {
     Source source = addSource(r'''
 class A {
@@ -3759,19 +3611,6 @@
     verify([source]);
   }
 
-  test_invalidTypeArgumentInConstSet() async {
-    Source source = addSource(r'''
-class A<E> {
-  m() {
-    return const <E>{};
-  }
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(
-        source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_SET]);
-    verify([source]);
-  }
-
   test_invalidUri_export() async {
     Source source = addSource("export 'ht:';");
     await computeAnalysisResult(source);
@@ -4774,48 +4613,6 @@
     ]);
   }
 
-  test_nonConstSetElement() async {
-    Source source = addSource(r'''
-f(a) {
-  return const {a};
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT]);
-    verify([source]);
-  }
-
-  test_nonConstSetElementFromDeferredLibrary() async {
-    await resolveWithErrors(<String>[
-      r'''
-library lib1;
-const int c = 1;''',
-      r'''
-library root;
-import 'lib1.dart' deferred as a;
-f() {
-  return const {a.c};
-}'''
-    ], [
-      CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT_FROM_DEFERRED_LIBRARY
-    ]);
-  }
-
-  test_nonConstSetElementFromDeferredLibrary_nested() async {
-    await resolveWithErrors(<String>[
-      r'''
-library lib1;
-const int c = 1;''',
-      r'''
-library root;
-import 'lib1.dart' deferred as a;
-f() {
-  return const {a.c + 1};
-}'''
-    ], [
-      CompileTimeErrorCode.NON_CONSTANT_SET_ELEMENT_FROM_DEFERRED_LIBRARY
-    ]);
-  }
-
   test_nonConstValueInInitializer_assert_condition() async {
     Source source = addSource(r'''
 class A {
diff --git a/pkg/analyzer/test/generated/non_error_resolver_driver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_driver_test.dart
index da8d07c..1871a37 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_driver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_driver_test.dart
@@ -1,10 +1,13 @@
-// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'non_error_resolver_test.dart';
+import 'resolver_test_case.dart';
 
 main() {
   defineReflectiveSuite(() {
@@ -13,6 +16,30 @@
 }
 
 @reflectiveTest
+class NonConstantValueInInitializer extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_isCheckInConstAssert() async {
+    Source source = addSource(r'''
+class C {
+  const C() : assert(1 is int);
+}
+
+void main() {
+  const C();
+}
+''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+}
+
+@reflectiveTest
 class NonErrorResolverTest_Driver extends NonErrorResolverTestBase {
   @override
   bool get enableNewAnalysisDriver => true;
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index 7b654ad..2b881c0 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -56,12 +56,6 @@
   }
 
   @override
-  @failingTest // Does not work with old task model
-  test_isCheckInConstAssert() {
-    return super.test_isCheckInConstAssert();
-  }
-
-  @override
   @failingTest // Fails with the old task model
   test_issue_32394() {
     return super.test_issue_32394();
@@ -3234,21 +3228,6 @@
     verify([source]);
   }
 
-  test_isCheckInConstAssert() async {
-    Source source = addSource(r'''
-class C {
-  const C() : assert(1 is int);
-}
-
-void main() {
-  const C();
-}
-''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   Future test_issue32114() async {
     addNamedSource('/a.dart', '''
 class O {}
diff --git a/pkg/analyzer/test/generated/resolver_test_case.dart b/pkg/analyzer/test/generated/resolver_test_case.dart
index 1880973..0057351 100644
--- a/pkg/analyzer/test/generated/resolver_test_case.dart
+++ b/pkg/analyzer/test/generated/resolver_test_case.dart
@@ -14,7 +14,6 @@
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
-import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/performance_logger.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ -343,6 +342,12 @@
    */
   AnalysisOptions get defaultAnalysisOptions => new AnalysisOptionsImpl();
 
+  /**
+   * Return the list of experiments that are to be enabled for tests in this
+   * class.
+   */
+  List<String> get enabledExperiments => null;
+
   bool get enableNewAnalysisDriver => false;
 
   /**
@@ -664,10 +669,10 @@
       fail('Only packages or options can be specified.');
     }
     options ??= defaultAnalysisOptions;
-    (options as AnalysisOptionsImpl).enabledExperiments = [
-      EnableString.constant_update_2018,
-      EnableString.set_literals
-    ];
+    List<String> experiments = enabledExperiments;
+    if (experiments != null) {
+      (options as AnalysisOptionsImpl).enabledExperiments = experiments;
+    }
     if (enableNewAnalysisDriver) {
       DartSdk sdk = new MockSdk(resourceProvider: resourceProvider)
         ..context.analysisOptions = options;
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index 310aa64..3d40fdc 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -8,6 +8,7 @@
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager2.dart';
@@ -34,6 +35,7 @@
     defineReflectiveTests(StaticTypeAnalyzerTest);
     defineReflectiveTests(StaticTypeAnalyzer2Test);
     defineReflectiveTests(StaticTypeAnalyzer3Test);
+    defineReflectiveTests(StaticTypeAnalyzerWithSetLiteralsTest);
   });
 }
 
@@ -187,6 +189,16 @@
 class StaticTypeAnalyzer3Test extends StaticTypeAnalyzer2TestShared {
   bool get enableNewAnalysisDriver => true;
 
+  test_emptyMapLiteral_initializer_var() async {
+    String code = r'''
+main() {
+  var v = {};
+}
+''';
+    await resolveTestUnit(code);
+    expectExpressionType('{}', 'Map<dynamic, dynamic>');
+  }
+
   test_emptyMapLiteral_parameter_typed() async {
     String code = r'''
 main() {
@@ -199,16 +211,6 @@
     expectExpressionType('{}', 'Map<int, int>');
   }
 
-  test_emptyMapLiteral_initializer_var() async {
-    String code = r'''
-main() {
-  var v = {};
-}
-''';
-    await resolveTestUnit(code);
-    expectExpressionType('{}', 'Map<dynamic, dynamic>');
-  }
-
   test_emptySetLiteral_parameter_typed() async {
     String code = r'''
 main() {
@@ -220,15 +222,6 @@
     await resolveTestUnit(code);
     expectExpressionType('{}', 'Set<int>');
   }
-
-  test_emptySetLiteral_initializer_typed_nested() async {
-    String code = r'''
-Set<Set<int>> ints = {{}};
-''';
-    await resolveTestUnit(code);
-    expectExpressionType('{}', 'Set<int>');
-    expectExpressionType('{{}}', 'Set<Set<int>>');
-  }
 }
 
 @reflectiveTest
@@ -1654,3 +1647,25 @@
     (element as ParameterElementImpl).type = type;
   }
 }
+
+/**
+ * End-to-end tests of the static type analyzer that use the new driver and
+ * enable the set-literals experiment.
+ */
+@reflectiveTest
+class StaticTypeAnalyzerWithSetLiteralsTest
+    extends StaticTypeAnalyzer2TestShared {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  bool get enableNewAnalysisDriver => true;
+
+  test_emptySetLiteral_initializer_typed_nested() async {
+    String code = r'''
+Set<Set<int>> ints = {{}};
+''';
+    await resolveTestUnit(code);
+    expectExpressionType('{}', 'Set<int>');
+    expectExpressionType('{{}}', 'Set<Set<int>>');
+  }
+}
diff --git a/pkg/analyzer/test/generated/static_warning_code_driver_test.dart b/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
index 699954f..ec8e367 100644
--- a/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
+++ b/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
@@ -1,23 +1,40 @@
-// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import 'resolver_test_case.dart';
 import 'static_warning_code_test.dart';
 
 main() {
   defineReflectiveSuite(() {
+    defineReflectiveTests(SetElementTypeNotAssignableTest);
     defineReflectiveTests(StaticWarningCodeTest_Driver);
   });
 }
 
 @reflectiveTest
+class SetElementTypeNotAssignableTest extends ResolverTestCase {
+  @override
+  List<String> get enabledExperiments => [EnableString.set_literals];
+
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  test_setElementTypeNotAssignable() async {
+    Source source = addSource("var v = <String>{42};");
+    await computeAnalysisResult(source);
+    assertErrors(source, [StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE]);
+    verify([source]);
+  }
+}
+
+@reflectiveTest
 class StaticWarningCodeTest_Driver extends StaticWarningCodeTest {
   @override
   bool get enableNewAnalysisDriver => true;
-
-  test_setElementTypeNotAssignable() async {
-    return super.test_setElementTypeNotAssignable();
-  }
 }
diff --git a/pkg/analyzer/test/generated/static_warning_code_test.dart b/pkg/analyzer/test/generated/static_warning_code_test.dart
index 07f6d2f..08e53a9 100644
--- a/pkg/analyzer/test/generated/static_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_warning_code_test.dart
@@ -3268,14 +3268,6 @@
     assertNoErrors(source);
   }
 
-  @failingTest
-  test_setElementTypeNotAssignable() async {
-    Source source = addSource("var v = <String>{42};");
-    await computeAnalysisResult(source);
-    assertErrors(source, [StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE]);
-    verify([source]);
-  }
-
   test_staticAccessToInstanceMember_method_invocation() async {
     Source source = addSource(r'''
 class A {
diff --git a/pkg/analyzer/test/src/dart/constant/evaluation_test.dart b/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
index 8716e0d..14189bb 100644
--- a/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
+++ b/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
@@ -28,11 +28,12 @@
   defineReflectiveSuite(() {
     defineReflectiveTests(ConstantVisitorTest);
     defineReflectiveTests(ConstantVisitorTest_Driver);
+    defineReflectiveTests(ConstantVisitorWithConstantUpdate2018Test);
   });
 }
 
 @reflectiveTest
-class ConstantVisitorTest extends ResolverTestCase {
+class ConstantVisitorTest extends ConstantVisitorTestSupport {
   test_visitAsExpression_instanceOfSameClass() async {
     CompilationUnit compilationUnit = await resolveSource('''
 const a = const A();
@@ -687,7 +688,14 @@
             typeSystem: new Dart2TypeSystem(typeProvider)),
         errorReporter));
   }
+}
 
+@reflectiveTest
+class ConstantVisitorTest_Driver extends ConstantVisitorTest {
+  bool get enableNewAnalysisDriver => true;
+}
+
+class ConstantVisitorTestSupport extends ResolverTestCase {
   DartObjectImpl _evaluateConstant(CompilationUnit compilationUnit, String name,
       {List<ErrorCode> errorCodes,
       List<String> experiments,
@@ -722,7 +730,11 @@
 }
 
 @reflectiveTest
-class ConstantVisitorTest_Driver extends ConstantVisitorTest {
+class ConstantVisitorWithConstantUpdate2018Test
+    extends ConstantVisitorTestSupport {
+  @override
+  List<String> get enabledExperiments => [EnableString.constant_update_2018];
+
   bool get enableNewAnalysisDriver => true;
 
   test_visitBinaryExpression_gtGtGt_negative_fewerBits() async {