diff --git a/pkg/compiler/lib/src/js_backend/field_analysis.dart b/pkg/compiler/lib/src/js_backend/field_analysis.dart
index 8489a25..33cb6c5 100644
--- a/pkg/compiler/lib/src/js_backend/field_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/field_analysis.dart
@@ -37,7 +37,7 @@
 class KFieldAnalysis implements FieldAnalysis {
   final KernelToElementMap _elementMap;
 
-  final Map<KField, AllocatorData> _fixedInitializers = {};
+  final Map<KClass, ClassData> _classData = {};
 
   KFieldAnalysis(KernelFrontEndStrategy kernelStrategy)
       : _elementMap = kernelStrategy.elementMap;
@@ -47,22 +47,27 @@
   void registerInstantiatedClass(KClass class_) {
     ir.Class classNode = _elementMap.getClassNode(class_);
 
-    Map<ir.Field, AllocatorData> fieldData = {};
+    List<KConstructor> constructors = [];
+    Map<KField, AllocatorData> fieldData = {};
     for (ir.Field field in classNode.fields) {
       if (!field.isInstanceMember) continue;
+
+      FieldEntity fieldElement = _elementMap.getField(field);
       ir.Expression expression = field.initializer;
       ConstantValue value = _elementMap.getConstantValue(expression,
           requireConstant: false, implicitNull: true);
       if (value != null && value.isConstant) {
-        fieldData[field] = new AllocatorData(value);
+        fieldData[fieldElement] = new AllocatorData(value);
       }
     }
 
     for (ir.Constructor constructor in classNode.constructors) {
       KConstructor constructorElement = _elementMap.getConstructor(constructor);
+      constructors.add(constructorElement);
       for (ir.Initializer initializer in constructor.initializers) {
         if (initializer is ir.FieldInitializer) {
-          AllocatorData data = fieldData[initializer.field];
+          AllocatorData data =
+              fieldData[_elementMap.getField(initializer.field)];
           if (data == null) {
             // TODO(johnniwinther): Support initializers with side-effects?
 
@@ -111,13 +116,19 @@
       }
     }
 
-    fieldData.forEach((ir.Field fieldNode, AllocatorData data) {
-      _fixedInitializers[_elementMap.getField(fieldNode)] = data;
-    });
+    _classData[class_] = new ClassData(constructors, fieldData);
   }
 
-  AllocatorData getFixedInitializerForTesting(KField field) =>
-      _fixedInitializers[field];
+  AllocatorData getFixedInitializerForTesting(KField field) {
+    return _classData[field.enclosingClass].fieldData[field];
+  }
+}
+
+class ClassData {
+  final List<KConstructor> constructors;
+  final Map<KField, AllocatorData> fieldData;
+
+  ClassData(this.constructors, this.fieldData);
 }
 
 class AllocatorData {
@@ -159,7 +170,7 @@
         name = null,
         value = null;
 
-  String shortText() {
+  String get shortText {
     switch (kind) {
       case InitializerKind.direct:
         return value.toStructuredText();
@@ -172,6 +183,8 @@
     }
     throw new UnsupportedError('Unexpected kind $kind');
   }
+
+  String toString() => shortText;
 }
 
 class JFieldAnalysis implements FieldAnalysis {
@@ -223,41 +236,103 @@
           !closedWorld.nativeData.isNativeMember(field);
     }
 
-    closedWorld.fieldAnalysis._fixedInitializers
-        .forEach((KField kField, AllocatorData data) {
-      JField jField = map.toBackendMember(kField);
-      if (jField == null) {
-        return;
-      }
-
-      // TODO(johnniwinther): Should elided static fields be removed from the
-      // J model? Static setters might still assign to them.
-
-      MemberUsage memberUsage = closedWorld.liveMemberUsage[kField];
-      if (!memberUsage.hasRead) {
-        if (canBeElided(kField)) {
-          elidedFields.add(jField);
+    closedWorld.fieldAnalysis._classData
+        .forEach((ClassEntity cls, ClassData classData) {
+      classData.fieldData.forEach((KField kField, AllocatorData data) {
+        JField jField = map.toBackendMember(kField);
+        if (jField == null) {
+          return;
         }
-      } else {
-        // TODO(johnniwinther): Use liveness of constructors and elided optional
-        // parameters to recognize more constant initializers.
-        if (data.initialValue != null && data.initializers.isEmpty) {
-          ConstantValue value = map.toBackendConstant(data.initialValue);
-          assert(value != null);
-          if (!memberUsage.hasWrite && canBeElided(kField)) {
+
+        // TODO(johnniwinther): Should elided static fields be removed from the
+        // J model? Static setters might still assign to them.
+
+        MemberUsage memberUsage = closedWorld.liveMemberUsage[kField];
+        if (!memberUsage.hasRead) {
+          if (canBeElided(kField)) {
             elidedFields.add(jField);
-            effectivelyConstantFields[jField] = value;
-          } else if (value.isNull ||
-              value.isInt ||
-              value.isBool ||
-              value.isString) {
-            // TODO(johnniwinther,sra): Support non-primitive constants in
-            // allocators when it does cause allocators to deoptimized because
-            // of deferred loading.
-            fixedInitializers[jField] = value;
+          }
+        } else {
+          // TODO(johnniwinther): Use liveness of constructors and elided optional
+          // parameters to recognize more constant initializers.
+          if (data.initialValue != null) {
+            ConstantValue initialValue;
+            bool isTooComplex = false;
+
+            void includeInitialValue(ConstantValue value) {
+              if (isTooComplex) return;
+              if (initialValue == null) {
+                initialValue = value;
+              } else if (initialValue != value) {
+                initialValue = null;
+                isTooComplex = true;
+              }
+            }
+
+            bool inAllConstructors = true;
+            for (KConstructor constructor in classData.constructors) {
+              if (isTooComplex) {
+                break;
+              }
+
+              MemberUsage constructorUsage =
+                  closedWorld.liveMemberUsage[constructor];
+              if (constructorUsage == null) return;
+              ParameterStructure invokedParameters =
+                  constructorUsage.invokedParameters;
+
+              Initializer initializer = data.initializers[constructor];
+              if (initializer == null) {
+                inAllConstructors = false;
+              } else {
+                switch (initializer.kind) {
+                  case InitializerKind.direct:
+                    includeInitialValue(initializer.value);
+                    break;
+                  case InitializerKind.positional:
+                    if (initializer.index >=
+                        invokedParameters.positionalParameters) {
+                      includeInitialValue(initializer.value);
+                    } else {
+                      isTooComplex = true;
+                    }
+                    break;
+                  case InitializerKind.named:
+                    if (!invokedParameters.namedParameters
+                        .contains(initializer.name)) {
+                      includeInitialValue(initializer.value);
+                    } else {
+                      isTooComplex = true;
+                    }
+                    break;
+                  case InitializerKind.complex:
+                    isTooComplex = true;
+                    break;
+                }
+              }
+            }
+            if (!inAllConstructors) {
+              includeInitialValue(data.initialValue);
+            }
+            if (!isTooComplex && initialValue != null) {
+              ConstantValue value = map.toBackendConstant(initialValue);
+              assert(value != null);
+              if (!memberUsage.hasWrite && canBeElided(kField)) {
+                elidedFields.add(jField);
+                effectivelyConstantFields[jField] = value;
+              } else if (value.isNull ||
+                  value.isInt ||
+                  value.isBool ||
+                  value.isString) {
+                // TODO(johnniwinther,sra): Support non-primitive constants in
+                // allocators when it does cause allocators to deoptimized
+                // because of deferred loading.
+                fixedInitializers[jField] = value;
+              }
+            }
           }
         }
-      }
+      });
     });
 
     // TODO(johnniwinther): Recognize effectively constant top level/static
diff --git a/tests/compiler/dart2js/codegen/expect_annotations2_test.dart b/tests/compiler/dart2js/codegen/expect_annotations2_test.dart
index 5b0ba5c..803520e 100644
--- a/tests/compiler/dart2js/codegen/expect_annotations2_test.dart
+++ b/tests/compiler/dart2js/codegen/expect_annotations2_test.dart
@@ -5,6 +5,7 @@
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 import 'package:compiler/compiler_new.dart';
+import 'package:compiler/src/commandline_options.dart';
 import '../helpers/memory_compiler.dart';
 
 const MEMORY_SOURCE_FILES = const {
@@ -15,6 +16,7 @@
         foo(y) => 49912344 + y;
 
         class A {
+          @pragma('dart2js:noElision')
           var field;
 
           @NoInline()
@@ -39,7 +41,9 @@
   runTest() async {
     OutputCollector collector = new OutputCollector();
     await runCompiler(
-        memorySourceFiles: MEMORY_SOURCE_FILES, outputProvider: collector);
+        memorySourceFiles: MEMORY_SOURCE_FILES,
+        outputProvider: collector,
+        options: [Flags.testMode]);
     // Simply check that the constants of the small functions are still in the
     // output, and that we don't see the result of constant folding.
     String jsOutput = collector.getOutput('', OutputType.js);
diff --git a/tests/compiler/dart2js/codegen/model_data/effectively_constant_state.dart b/tests/compiler/dart2js/codegen/model_data/effectively_constant_state.dart
new file mode 100644
index 0000000..fc33c4b
--- /dev/null
+++ b/tests/compiler/dart2js/codegen/model_data/effectively_constant_state.dart
@@ -0,0 +1,92 @@
+// Copyright (c) 2019, 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.
+
+enum Enum {
+  a,
+  b,
+  c,
+}
+
+/*element: tester1:params=0*/
+@pragma('dart2js:noInline')
+tester1() {}
+
+/*element: tester2:params=0*/
+@pragma('dart2js:noInline')
+tester2() {}
+
+/*element: tester3:params=0*/
+@pragma('dart2js:noInline')
+tester3() {}
+
+class Class {
+  /*element: Class.state1:elided*/
+  final int state1;
+
+  /*element: Class.state2:elided*/
+  final Enum state2;
+
+  Class({this.state1: 1, this.state2: Enum.c});
+
+  /*element: Class.method1a:calls=[tester2(0)],params=0*/
+  @pragma('dart2js:noInline')
+  method1a() {
+    if (state1 == 0) {
+      return tester1();
+    } else if (state1 == 1) {
+      return tester2();
+    } else if (state1 == 2) {
+      return tester3();
+    }
+  }
+
+  // TODO(johnniwinther): Inline switch cases with constant expressions.
+  /*element: Class.method1b:calls=[tester2(0)],params=0,switch*/
+  @pragma('dart2js:noInline')
+  method1b() {
+    switch (state1) {
+      case 0:
+        return tester1();
+      case 1:
+        return tester2();
+      case 2:
+        return tester3();
+    }
+  }
+
+  /*element: Class.method2a:calls=[tester3(0)],params=0*/
+  @pragma('dart2js:noInline')
+  method2a() {
+    if (state2 == Enum.a) {
+      return tester1();
+    } else if (state2 == Enum.b) {
+      return tester2();
+    } else if (state2 == Enum.c) {
+      return tester3();
+    }
+  }
+
+  /*element: Class.method2b:calls=[tester1(0),tester2(0),tester3(0)],params=0,switch*/
+  @pragma('dart2js:noInline')
+  method2b() {
+    // TODO(johnniwinther): Eliminate dead code in enum switch.
+    switch (state2) {
+      case Enum.a:
+        return tester1();
+      case Enum.b:
+        return tester2();
+      case Enum.c:
+        return tester3();
+    }
+  }
+}
+
+/*element: main:calls=*,params=0*/
+main() {
+  var c = new Class();
+  c.method1a();
+  c.method1b();
+  c.method2a();
+  c.method2b();
+}
diff --git a/tests/compiler/dart2js/codegen/model_test.dart b/tests/compiler/dart2js/codegen/model_test.dart
index 974ca4a..7e1262d 100644
--- a/tests/compiler/dart2js/codegen/model_test.dart
+++ b/tests/compiler/dart2js/codegen/model_test.dart
@@ -64,6 +64,7 @@
   static const String assignment = 'assign';
   static const String isLazy = 'lazy';
   static const String propertyAccess = 'access';
+  static const String switchCase = 'switch';
 }
 
 /// AST visitor for computing inference data for a member.
@@ -222,6 +223,11 @@
             features.addElement(Tags.propertyAccess, '${name}');
           }
         });
+
+        forEachNode(code, onSwitch: (js.Switch node) {
+          features.add(Tags.switchCase);
+        });
+
         return features;
       }
     }
diff --git a/tests/compiler/dart2js/field_analysis/jdata/effectively_constant_state.dart b/tests/compiler/dart2js/field_analysis/jdata/effectively_constant_state.dart
new file mode 100644
index 0000000..84f532e
--- /dev/null
+++ b/tests/compiler/dart2js/field_analysis/jdata/effectively_constant_state.dart
@@ -0,0 +1,82 @@
+// Copyright (c) 2019, 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.
+
+enum Enum {
+  a,
+  b,
+  c,
+}
+
+@pragma('dart2js:noInline')
+tester1() {}
+
+@pragma('dart2js:noInline')
+tester2() {}
+
+@pragma('dart2js:noInline')
+tester3() {}
+
+class Class {
+  /*element: Class.state1:constant=IntConstant(1)*/
+  final int state1;
+
+  /*element: Class.state2:constant=ConstructedConstant(Enum(_name=StringConstant("Enum.c"),index=IntConstant(2)))*/
+  final Enum state2;
+
+  Class({this.state1: 1, this.state2: Enum.c});
+
+  @pragma('dart2js:noInline')
+  method1a() {
+    if (state1 == 0) {
+      return tester1();
+    } else if (state1 == 1) {
+      return tester2();
+    } else if (state1 == 2) {
+      return tester3();
+    }
+  }
+
+  @pragma('dart2js:noInline')
+  method1b() {
+    switch (state1) {
+      case 0:
+        return tester1();
+      case 1:
+        return tester2();
+      case 2:
+        return tester3();
+    }
+  }
+
+  @pragma('dart2js:noInline')
+  method2a() {
+    if (state2 == Enum.a) {
+      return tester1();
+    } else if (state2 == Enum.b) {
+      return tester2();
+    } else if (state2 == Enum.c) {
+      return tester3();
+    }
+  }
+
+  @pragma('dart2js:noInline')
+  method2b() {
+    switch (state2) {
+      case Enum.a:
+        return tester1();
+      case Enum.b:
+        return tester2();
+      case Enum.c:
+        return tester3();
+    }
+  }
+}
+
+main() {
+  var c = new Class();
+  c.method1a();
+  c.method1b();
+  c.method2a();
+  c.method2b();
+}
diff --git a/tests/compiler/dart2js/field_analysis/jdata/multi_initializers.dart b/tests/compiler/dart2js/field_analysis/jdata/multi_initializers.dart
index d72731d..f7d423f 100644
--- a/tests/compiler/dart2js/field_analysis/jdata/multi_initializers.dart
+++ b/tests/compiler/dart2js/field_analysis/jdata/multi_initializers.dart
@@ -4,21 +4,30 @@
 
 main() {
   var c = new Class1.a();
+  c.field3a = null;
   c.field4a = null;
+  c.field5a = null;
   new Class1.b();
 
   print(c.field1);
   print(c.field2);
-  print(c.field3);
+  print(c.field3a);
+  print(c.field3b);
   print(c.field4a);
   print(c.field4b);
-  print(c.field5);
+  print(c.field5a);
+  print(c.field5b);
 }
 
 class Class1 {
   var field1 = 0;
   var field2;
-  var field3;
+
+  /*element: Class1.field3a:initial=IntConstant(3)*/
+  var field3a;
+
+  /*element: Class1.field3b:constant=IntConstant(3)*/
+  var field3b;
 
   /*element: Class1.field4a:initial=IntConstant(4)*/
   var field4a = 4;
@@ -26,16 +35,24 @@
   /*element: Class1.field4b:constant=IntConstant(4)*/
   var field4b = 4;
 
-  var field5 = 5;
+  /*element: Class1.field5a:initial=IntConstant(5)*/
+  var field5a = 5;
+
+  /*element: Class1.field5b:constant=IntConstant(5)*/
+  var field5b = 5;
 
   Class1.a()
       : field1 = 1,
         field2 = 1,
-        field3 = 3,
-        field5 = 5;
+        field3a = 3,
+        field3b = 3,
+        field5a = 5,
+        field5b = 5;
 
   Class1.b()
       : field2 = 2,
-        field3 = 3,
-        field5 = 5;
+        field3a = 3,
+        field3b = 3,
+        field5a = 5,
+        field5b = 5;
 }
diff --git a/tests/compiler/dart2js/field_analysis/jdata/optional_parameters.dart b/tests/compiler/dart2js/field_analysis/jdata/optional_parameters.dart
index cad9372..2f63ffb 100644
--- a/tests/compiler/dart2js/field_analysis/jdata/optional_parameters.dart
+++ b/tests/compiler/dart2js/field_analysis/jdata/optional_parameters.dart
@@ -3,24 +3,85 @@
 // BSD-style license that can be found in the LICENSE file.
 
 main() {
-  new Class1(0);
-  new Class1(0, 1);
-  new Class2(0);
-  new Class2(0, field2: 1);
+  var c1a = new Class1a(0);
+  new Class1a(0, 1);
+  c1a.field1 = null;
+  c1a.field2 = null;
+  c1a.field3 = null;
+  print(c1a.field1);
+  print(c1a.field2);
+  print(c1a.field3);
+
+  var c1b = new Class1b(0);
+  new Class1b(0, 1);
+  print(c1b.field1);
+  print(c1b.field2);
+  print(c1b.field3);
+
+  var c2a = new Class2a(0);
+  new Class2a(0, field2: 1);
+  c2a.field1 = null;
+  c2a.field2 = null;
+  c2a.field3 = null;
+  print(c2a.field1);
+  print(c2a.field2);
+  print(c2a.field3);
+
+  var c2b = new Class2b(0);
+  new Class2b(0, field2: 1);
+  print(c2b.field1);
+  print(c2b.field2);
+  print(c2b.field3);
 }
 
-class Class1 {
+class Class1a {
+  /*element: Class1a.field1:*/
   var field1;
+
+  /*element: Class1a.field2:*/
   var field2;
+
+  /*element: Class1a.field3:initial=IntConstant(3)*/
   var field3;
 
-  Class1(this.field1, [this.field2 = 2, this.field3 = 3]);
+  Class1a(this.field1, [this.field2 = 2, this.field3 = 3]);
 }
 
-class Class2 {
+class Class1b {
+  /*element: Class1b.field1:*/
   var field1;
+
+  /*element: Class1b.field2:*/
   var field2;
+
+  /*element: Class1b.field3:constant=IntConstant(3)*/
   var field3;
 
-  Class2(this.field1, {this.field2 = 2, this.field3 = 3});
+  Class1b(this.field1, [this.field2 = 2, this.field3 = 3]);
+}
+
+class Class2a {
+  /*element: Class2a.field1:*/
+  var field1;
+
+  /*element: Class2a.field2:*/
+  var field2;
+
+  /*element: Class2a.field3:initial=IntConstant(3)*/
+  var field3;
+
+  Class2a(this.field1, {this.field2 = 2, this.field3 = 3});
+}
+
+class Class2b {
+  /*element: Class2b.field1:*/
+  var field1;
+
+  /*element: Class2b.field2:*/
+  var field2;
+
+  /*element: Class2b.field3:constant=IntConstant(3)*/
+  var field3;
+
+  Class2b(this.field1, {this.field2 = 2, this.field3 = 3});
 }
diff --git a/tests/compiler/dart2js/field_analysis/jdata/simple_initializers.dart b/tests/compiler/dart2js/field_analysis/jdata/simple_initializers.dart
index 0a5a612..a18580f 100644
--- a/tests/compiler/dart2js/field_analysis/jdata/simple_initializers.dart
+++ b/tests/compiler/dart2js/field_analysis/jdata/simple_initializers.dart
@@ -214,94 +214,94 @@
 }
 
 class Class2 {
-  /*element: Class2.field1a:*/
+  /*element: Class2.field1a:initial=NullConstant*/
   var field1a;
 
-  /*element: Class2.field1b:*/
+  /*element: Class2.field1b:constant=NullConstant*/
   var field1b;
 
-  /*element: Class2.field2a:*/
+  /*element: Class2.field2a:initial=BoolConstant(true)*/
   var field2a;
 
-  /*element: Class2.field2b:*/
+  /*element: Class2.field2b:constant=BoolConstant(true)*/
   var field2b;
 
-  /*element: Class2.field3a:*/
+  /*element: Class2.field3a:initial=BoolConstant(false)*/
   var field3a;
 
-  /*element: Class2.field3b:*/
+  /*element: Class2.field3b:constant=BoolConstant(false)*/
   var field3b;
 
-  /*element: Class2.field4a:*/
+  /*element: Class2.field4a:initial=IntConstant(0)*/
   var field4a;
 
-  /*element: Class2.field4b:*/
+  /*element: Class2.field4b:constant=IntConstant(0)*/
   var field4b;
 
-  /*element: Class2.field5a:*/
+  /*element: Class2.field5a:initial=IntConstant(1)*/
   var field5a;
 
-  /*element: Class2.field5b:*/
+  /*element: Class2.field5b:constant=IntConstant(1)*/
   var field5b;
 
-  /*element: Class2.field6a:*/
+  /*element: Class2.field6a:initial=StringConstant("")*/
   var field6a;
 
-  /*element: Class2.field6b:*/
+  /*element: Class2.field6b:constant=StringConstant("")*/
   var field6b;
 
-  /*element: Class2.field7a:*/
+  /*element: Class2.field7a:initial=StringConstant("foo")*/
   var field7a;
 
-  /*element: Class2.field7b:*/
+  /*element: Class2.field7b:constant=StringConstant("foo")*/
   var field7b;
 
   /*element: Class2.field8a:*/
   var field8a;
 
-  /*element: Class2.field8b:*/
+  /*element: Class2.field8b:constant=DoubleConstant(0.5)*/
   var field8b;
 
   /*element: Class2.field9a:*/
   var field9a;
 
-  /*element: Class2.field9b:*/
+  /*element: Class2.field9b:constant=ListConstant([])*/
   var field9b;
 
   /*element: Class2.field9c:*/
   var field9c;
 
-  /*element: Class2.field9d:*/
+  /*element: Class2.field9d:constant=ListConstant(<int>[IntConstant(0), IntConstant(1), IntConstant(2)])*/
   var field9d;
 
   /*element: Class2.field10a:*/
   var field10a;
 
-  /*element: Class2.field10b:*/
+  /*element: Class2.field10b:constant=MapConstant({})*/
   var field10b;
 
   /*element: Class2.field10c:*/
   var field10c;
 
-  /*element: Class2.field10d:*/
+  /*element: Class2.field10d:constant=MapConstant(<int, int>{IntConstant(0): IntConstant(1), IntConstant(2): IntConstant(3), IntConstant(4): IntConstant(5)})*/
   var field10d;
 
   /*element: Class2.field11a:*/
   var field11a;
 
-  /*element: Class2.field11b:*/
+  /*element: Class2.field11b:constant=ConstructedConstant(Symbol(_name=StringConstant("foo")))*/
   var field11b;
 
-  /*element: Class2.field12a:*/
+  /*element: Class2.field12a:initial=IntConstant(5)*/
   var field12a;
 
-  /*element: Class2.field12b:*/
+  /*element: Class2.field12b:constant=IntConstant(5)*/
   var field12b;
 
-  /*element: Class2.field13a:*/
+  /*element: Class2.field13a:initial=BoolConstant(true)*/
   var field13a;
 
-  /*element: Class2.field13b:*/
+  /*element: Class2.field13b:constant=BoolConstant(true)*/
   var field13b;
 
   Class2()
diff --git a/tests/compiler/dart2js/field_analysis/kfield_analysis_test.dart b/tests/compiler/dart2js/field_analysis/kfield_analysis_test.dart
index fbc8b7e..124ff4c 100644
--- a/tests/compiler/dart2js/field_analysis/kfield_analysis_test.dart
+++ b/tests/compiler/dart2js/field_analysis/kfield_analysis_test.dart
@@ -47,7 +47,7 @@
         }
         data.initializers.forEach((constructor, value) {
           features['${constructor.enclosingClass.name}.${constructor.name}'] =
-              value?.shortText();
+              value?.shortText;
         });
       }
       Id id = computeEntityId(node);
diff --git a/tests/compiler/dart2js/helpers/program_lookup.dart b/tests/compiler/dart2js/helpers/program_lookup.dart
index cac728c..ccbf049 100644
--- a/tests/compiler/dart2js/helpers/program_lookup.dart
+++ b/tests/compiler/dart2js/helpers/program_lookup.dart
@@ -227,11 +227,13 @@
 void forEachNode(js.Node root,
     {void Function(js.Call) onCall,
     void Function(js.PropertyAccess) onPropertyAccess,
-    void Function(js.Assignment) onAssignment}) {
+    void Function(js.Assignment) onAssignment,
+    void Function(js.Switch) onSwitch}) {
   CallbackVisitor visitor = new CallbackVisitor(
       onCall: onCall,
       onPropertyAccess: onPropertyAccess,
-      onAssignment: onAssignment);
+      onAssignment: onAssignment,
+      onSwitch: onSwitch);
   root.accept(visitor);
 }
 
@@ -239,8 +241,10 @@
   final void Function(js.Call) onCall;
   final void Function(js.PropertyAccess) onPropertyAccess;
   final void Function(js.Assignment) onAssignment;
+  final void Function(js.Switch) onSwitch;
 
-  CallbackVisitor({this.onCall, this.onPropertyAccess, this.onAssignment});
+  CallbackVisitor(
+      {this.onCall, this.onPropertyAccess, this.onAssignment, this.onSwitch});
 
   @override
   visitCall(js.Call node) {
@@ -259,4 +263,10 @@
     if (onAssignment != null) onAssignment(node);
     return super.visitAssignment(node);
   }
+
+  @override
+  visitSwitch(js.Switch node) {
+    if (onSwitch != null) onSwitch(node);
+    return super.visitSwitch(node);
+  }
 }
diff --git a/tests/compiler/dart2js/inlining/meta_annotations2_test.dart b/tests/compiler/dart2js/inlining/meta_annotations2_test.dart
index 27e0277..d809601 100644
--- a/tests/compiler/dart2js/inlining/meta_annotations2_test.dart
+++ b/tests/compiler/dart2js/inlining/meta_annotations2_test.dart
@@ -7,6 +7,7 @@
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 import 'package:compiler/compiler_new.dart';
+import 'package:compiler/src/commandline_options.dart';
 import '../helpers/memory_compiler.dart';
 
 const MEMORY_SOURCE_FILES = const {
@@ -17,6 +18,7 @@
         foo(y) => 49912344 + y;
 
         class A {
+          @pragma('dart2js:noElision')
           var field;
 
           @noInline
@@ -41,7 +43,9 @@
   runTests() async {
     OutputCollector collector = new OutputCollector();
     await runCompiler(
-        memorySourceFiles: MEMORY_SOURCE_FILES, outputProvider: collector);
+        memorySourceFiles: MEMORY_SOURCE_FILES,
+        outputProvider: collector,
+        options: [Flags.testMode]);
     // Simply check that the constants of the small functions are still in the
     // output, and that we don't see the result of constant folding.
     String jsOutput = collector.getOutput('', OutputType.js);