Replace try/fail/catch for EvaluationException with expect(throws).

pkg/analyzer/test/src/dart/constant/value_test.dart

 // 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.
 
 library analyzer.test.src.dart.constant.value_test;
 
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../../generated/test_support.dart';
 import '../../../utils.dart';
 
 main() {
   initializeTestEnvironment();
   defineReflectiveTests(DartObjectImplTest);
 }
 
+const Matcher isEvaluationException = const isInstanceOf<EvaluationException>();
+
 const int LONG_MAX_VALUE = 0x7fffffffffffffff;
 
+const Matcher throwsEvaluationException = const Throws(isEvaluationException);
+
 @reflectiveTest
 class DartObjectImplTest extends EngineTestCase {
   TypeProvider _typeProvider = new TestTypeProvider();
 
   void test_add_knownDouble_knownDouble() {
     _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _doubleValue(2.0));
   }
 
   void test_add_knownDouble_knownInt() {
     _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _intValue(2));
@@ skipping 921 matching lines @@
 
   void test_lessThanOrEqual_unknownInt_knownInt() {
     _assertLessThanOrEqual(_boolValue(null), _intValue(null), _intValue(2));
   }
 
   void test_logicalAnd_false_false() {
     _assertLogicalAnd(_boolValue(false), _boolValue(false), _boolValue(false));
   }
 
   void test_logicalAnd_false_null() {
-    try {
+    expect(() {
       _assertLogicalAnd(_boolValue(false), _boolValue(false), _nullValue());
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_false_string() {
-    try {
+    expect(() {
       _assertLogicalAnd(
           _boolValue(false), _boolValue(false), _stringValue("false"));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_false_true() {
     _assertLogicalAnd(_boolValue(false), _boolValue(false), _boolValue(true));
   }
 
   void test_logicalAnd_null_false() {
-    try {
+    expect(() {
       _assertLogicalAnd(_boolValue(false), _nullValue(), _boolValue(false));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_null_true() {
-    try {
+    expect(() {
       _assertLogicalAnd(_boolValue(false), _nullValue(), _boolValue(true));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_string_false() {
-    try {
+    expect(() {
       _assertLogicalAnd(
           _boolValue(false), _stringValue("true"), _boolValue(false));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_string_true() {
-    try {
+    expect(() {
       _assertLogicalAnd(
           _boolValue(false), _stringValue("false"), _boolValue(true));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_true_false() {
     _assertLogicalAnd(_boolValue(false), _boolValue(true), _boolValue(false));
   }
 
   void test_logicalAnd_true_null() {
     _assertLogicalAnd(null, _boolValue(true), _nullValue());
   }
 
   void test_logicalAnd_true_string() {
-    try {
+    expect(() {
       _assertLogicalAnd(
           _boolValue(false), _boolValue(true), _stringValue("true"));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalAnd_true_true() {
     _assertLogicalAnd(_boolValue(true), _boolValue(true), _boolValue(true));
   }
 
   void test_logicalNot_false() {
     _assertLogicalNot(_boolValue(true), _boolValue(false));
   }
 
   void test_logicalNot_null() {
     _assertLogicalNot(null, _nullValue());
   }
 
   void test_logicalNot_string() {
-    try {
+    expect(() {
       _assertLogicalNot(_boolValue(true), _stringValue(null));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalNot_true() {
     _assertLogicalNot(_boolValue(false), _boolValue(true));
   }
 
   void test_logicalNot_unknown() {
     _assertLogicalNot(_boolValue(null), _boolValue(null));
   }
 
   void test_logicalOr_false_false() {
     _assertLogicalOr(_boolValue(false), _boolValue(false), _boolValue(false));
   }
 
   void test_logicalOr_false_null() {
     _assertLogicalOr(null, _boolValue(false), _nullValue());
   }
 
   void test_logicalOr_false_string() {
-    try {
+    expect(() {
       _assertLogicalOr(
           _boolValue(false), _boolValue(false), _stringValue("false"));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_false_true() {
     _assertLogicalOr(_boolValue(true), _boolValue(false), _boolValue(true));
   }
 
   void test_logicalOr_null_false() {
-    try {
+    expect(() {
       _assertLogicalOr(_boolValue(false), _nullValue(), _boolValue(false));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_null_true() {
-    try {
+    expect(() {
       _assertLogicalOr(_boolValue(true), _nullValue(), _boolValue(true));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_string_false() {
-    try {
+    expect(() {
       _assertLogicalOr(
           _boolValue(false), _stringValue("true"), _boolValue(false));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_string_true() {
-    try {
+    expect(() {
       _assertLogicalOr(
           _boolValue(true), _stringValue("false"), _boolValue(true));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_true_false() {
     _assertLogicalOr(_boolValue(true), _boolValue(true), _boolValue(false));
   }
 
   void test_logicalOr_true_null() {
-    try {
+    expect(() {
       _assertLogicalOr(_boolValue(true), _boolValue(true), _nullValue());
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_true_string() {
-    try {
+    expect(() {
       _assertLogicalOr(
           _boolValue(true), _boolValue(true), _stringValue("true"));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_logicalOr_true_true() {
     _assertLogicalOr(_boolValue(true), _boolValue(true), _boolValue(true));
   }
 
   void test_minus_knownDouble_knownDouble() {
     _assertMinus(_doubleValue(1.0), _doubleValue(4.0), _doubleValue(3.0));
   }
 
@@ skipping 268 matching lines @@
 
   void test_shiftRight_unknownInt_knownInt() {
     _assertShiftRight(_intValue(null), _intValue(null), _intValue(3));
   }
 
   void test_shiftRight_unknownInt_unknownInt() {
     _assertShiftRight(_intValue(null), _intValue(null), _intValue(null));
   }
 
   void test_stringLength_int() {
-    try {
+    expect(() {
       _assertStringLength(_intValue(null), _intValue(0));
-      fail("Expected EvaluationException");
-    } on EvaluationException {}
+    }, throwsEvaluationException);
   }
 
   void test_stringLength_knownString() {
     _assertStringLength(_intValue(3), _stringValue("abc"));
   }
 
   void test_stringLength_unknownString() {
     _assertStringLength(_intValue(null), _stringValue(null));
   }
 
@@ skipping 50 matching lines @@
   }
 
   /**
    * Assert that the result of adding the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertAdd(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.add(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.add(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of bit-anding the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertBitAnd(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.bitAnd(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.bitAnd(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the bit-not of the [operand] is the [expected] value, or that
    * the operation throws an exception if the expected value is `null`.
    */
   void _assertBitNot(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
-      try {
+      expect(() {
         operand.bitNot(_typeProvider);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = operand.bitNot(_typeProvider);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of bit-oring the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertBitOr(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.bitOr(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.bitOr(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of bit-xoring the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertBitXor(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.bitXor(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.bitXor(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of concatenating the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertConcatenate(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.concatenate(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.concatenate(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of dividing the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertDivide(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.divide(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.divide(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands for
    * equality is the [expected] value, or that the operation throws an exception
    * if the expected value is `null`.
    */
   void _assertEqualEqual(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.equalEqual(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.equalEqual(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertGreaterThan(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.greaterThan(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.greaterThan(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertGreaterThanOrEqual(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.greaterThanOrEqual(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.greaterThanOrEqual(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands using
    * identical() is the expected value.
@@ skipping 10 matching lines @@
   }
 
   /**
    * Assert that the result of dividing the [left] and [right] operands as
    * integers is the [expected] value, or that the operation throws an exception
    * if the expected value is `null`.
    */
   void _assertIntegerDivide(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.integerDivide(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.integerDivide(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertLessThan(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.lessThan(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.lessThan(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands is the
    * [expected] value, or that the operation throws an exception if the expected
    * value is `null`.
    */
   void _assertLessThanOrEqual(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.lessThanOrEqual(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.lessThanOrEqual(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of logical-anding the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertLogicalAnd(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.logicalAnd(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.logicalAnd(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the logical-not of the [operand] is the [expected] value, or
    * that the operation throws an exception if the expected value is `null`.
    */
   void _assertLogicalNot(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
-      try {
+      expect(() {
         operand.logicalNot(_typeProvider);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = operand.logicalNot(_typeProvider);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of logical-oring the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertLogicalOr(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.logicalOr(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.logicalOr(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of subtracting the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertMinus(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.minus(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.minus(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the negation of the [operand] is the [expected] value, or that
    * the operation throws an exception if the expected value is `null`.
    */
   void _assertNegated(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
-      try {
+      expect(() {
         operand.negated(_typeProvider);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = operand.negated(_typeProvider);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the [left] and [right] operands for
    * inequality is the [expected] value, or that the operation throws an
    * exception if the expected value is `null`.
    */
   void _assertNotEqual(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.notEqual(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.notEqual(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that converting the [operand] to a string is the [expected] value,
    * or that the operation throws an exception if the expected value is `null`.
    */
   void _assertPerformToString(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
-      try {
+      expect(() {
         operand.performToString(_typeProvider);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = operand.performToString(_typeProvider);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of taking the remainder of the [left] and [right]
    * operands is the [expected] value, or that the operation throws an exception
    * if the expected value is `null`.
    */
   void _assertRemainder(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.remainder(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.remainder(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of multiplying the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertShiftLeft(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.shiftLeft(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.shiftLeft(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of multiplying the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertShiftRight(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.shiftRight(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.shiftRight(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the length of the [operand] is the [expected] value, or that
    * the operation throws an exception if the expected value is `null`.
    */
   void _assertStringLength(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
-      try {
+      expect(() {
         operand.stringLength(_typeProvider);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = operand.stringLength(_typeProvider);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of multiplying the [left] and [right] operands is
    * the [expected] value, or that the operation throws an exception if the
    * expected value is `null`.
    */
   void _assertTimes(
       DartObjectImpl expected, DartObjectImpl left, DartObjectImpl right) {
     if (expected == null) {
-      try {
+      expect(() {
         left.times(_typeProvider, right);
-        fail("Expected an EvaluationException");
-      } on EvaluationException {}
+      }, throwsEvaluationException);
     } else {
       DartObjectImpl result = left.times(_typeProvider, right);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   DartObjectImpl _boolValue(bool value) {
     if (value == null) {
       return new DartObjectImpl(
@@ skipping 61 matching lines @@
     } else {
       return new DartObjectImpl(
           _typeProvider.stringType, new StringState(value));
     }
   }
 
   DartObjectImpl _symbolValue(String value) {
     return new DartObjectImpl(_typeProvider.symbolType, new SymbolState(value));
   }
 }