Fix hints in the analyzer package.

pkg/analyzer/test/generated/all_the_rest_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 3304 matching lines @@
   }
 
   void test_logicalAnd_false_false() {
     _assertLogicalAnd(_boolValue(false), _boolValue(false), _boolValue(false));
   }
 
   void test_logicalAnd_false_null() {
     try {
       _assertLogicalAnd(_boolValue(false), _boolValue(false), _nullValue());
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalAnd_false_string() {
     try {
       _assertLogicalAnd(
           _boolValue(false), _boolValue(false), _stringValue("false"));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalAnd_false_true() {
     _assertLogicalAnd(_boolValue(false), _boolValue(false), _boolValue(true));
   }
 
   void test_logicalAnd_null_false() {
     try {
       _assertLogicalAnd(_boolValue(false), _nullValue(), _boolValue(false));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalAnd_null_true() {
     try {
       _assertLogicalAnd(_boolValue(false), _nullValue(), _boolValue(true));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalAnd_string_false() {
     try {
       _assertLogicalAnd(
           _boolValue(false), _stringValue("true"), _boolValue(false));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalAnd_string_true() {
     try {
       _assertLogicalAnd(
           _boolValue(false), _stringValue("false"), _boolValue(true));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   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 {
       _assertLogicalAnd(
           _boolValue(false), _boolValue(true), _stringValue("true"));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   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 {
       _assertLogicalNot(_boolValue(true), _stringValue(null));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   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 {
       _assertLogicalOr(
           _boolValue(false), _boolValue(false), _stringValue("false"));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_false_true() {
     _assertLogicalOr(_boolValue(true), _boolValue(false), _boolValue(true));
   }
 
   void test_logicalOr_null_false() {
     try {
       _assertLogicalOr(_boolValue(false), _nullValue(), _boolValue(false));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_null_true() {
     try {
       _assertLogicalOr(_boolValue(true), _nullValue(), _boolValue(true));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_string_false() {
     try {
       _assertLogicalOr(
           _boolValue(false), _stringValue("true"), _boolValue(false));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_string_true() {
     try {
       _assertLogicalOr(
           _boolValue(true), _stringValue("false"), _boolValue(true));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_true_false() {
     _assertLogicalOr(_boolValue(true), _boolValue(true), _boolValue(false));
   }
 
   void test_logicalOr_true_null() {
     try {
       _assertLogicalOr(_boolValue(true), _boolValue(true), _nullValue());
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_logicalOr_true_string() {
     try {
       _assertLogicalOr(
           _boolValue(true), _boolValue(true), _stringValue("true"));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   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 265 matching lines @@
   }
 
   void test_shiftRight_unknownInt_unknownInt() {
     _assertShiftRight(_intValue(null), _intValue(null), _intValue(null));
   }
 
   void test_stringLength_int() {
     try {
       _assertStringLength(_intValue(null), _intValue(0));
       fail("Expected EvaluationException");
-    } on EvaluationException catch (exception) {}
+    } on EvaluationException {}
   }
 
   void test_stringLength_knownString() {
     _assertStringLength(_intValue(3), _stringValue("abc"));
   }
 
   void test_stringLength_unknownString() {
     _assertStringLength(_intValue(null), _stringValue(null));
   }
 
@@ skipping 57 matching lines @@
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertAdd(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.add(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.add(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertBitAnd(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.bitAnd(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.bitAnd(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param operand the operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertBitNot(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
       try {
         operand.bitNot(_typeProvider);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } 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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertBitOr(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.bitOr(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.bitOr(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertBitXor(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.bitXor(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.bitXor(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertConcatenate(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.concatenate(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.concatenate(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertDivide(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.divide(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.divide(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertEqualEqual(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.equalEqual(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.equalEqual(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertGreaterThan(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.greaterThan(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.greaterThan(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertGreaterThanOrEqual(DartObjectImpl expected,
       DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.greaterThanOrEqual(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.greaterThanOrEqual(_typeProvider, rightOperand);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   /**
    * Assert that the result of comparing the left and right operands using
@@ skipping 23 matching lines @@
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertIntegerDivide(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.integerDivide(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.integerDivide(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertLessThan(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.lessThan(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.lessThan(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertLessThanOrEqual(DartObjectImpl expected,
       DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.lessThanOrEqual(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.lessThanOrEqual(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertLogicalAnd(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.logicalAnd(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.logicalAnd(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param operand the operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertLogicalNot(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
       try {
         operand.logicalNot(_typeProvider);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } 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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertLogicalOr(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.logicalOr(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.logicalOr(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertMinus(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.minus(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.minus(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param operand the operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertNegated(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
       try {
         operand.negated(_typeProvider);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } 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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertNotEqual(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.notEqual(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.notEqual(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param operand the operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertPerformToString(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
       try {
         operand.performToString(_typeProvider);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } 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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertRemainder(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.remainder(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.remainder(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertShiftLeft(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.shiftLeft(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.shiftLeft(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertShiftRight(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.shiftRight(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result =
           leftOperand.shiftRight(_typeProvider, rightOperand);
       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`.
    *
    * @param expected the expected result of the operation
    * @param operand the operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertStringLength(DartObjectImpl expected, DartObjectImpl operand) {
     if (expected == null) {
       try {
         operand.stringLength(_typeProvider);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } 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`.
    *
    * @param expected the expected result of the operation
    * @param leftOperand the left operand to the operation
    * @param rightOperand the left operand to the operation
    * @throws EvaluationException if the result is an exception when it should not be
    */
   void _assertTimes(DartObjectImpl expected, DartObjectImpl leftOperand,
       DartObjectImpl rightOperand) {
     if (expected == null) {
       try {
         leftOperand.times(_typeProvider, rightOperand);
         fail("Expected an EvaluationException");
-      } on EvaluationException catch (exception) {}
+      } on EvaluationException {}
     } else {
       DartObjectImpl result = leftOperand.times(_typeProvider, rightOperand);
       expect(result, isNotNull);
       expect(result, expected);
     }
   }
 
   DartObjectImpl _boolValue(bool value) {
     if (value == null) {
       return new DartObjectImpl(
@@ skipping 3601 matching lines @@
 @reflectiveTest
 class SourceFactoryTest {
   void test_creation() {
     expect(new SourceFactory([]), isNotNull);
   }
   void test_fromEncoding_invalidUri() {
     SourceFactory factory = new SourceFactory([]);
     try {
       factory.fromEncoding("<:&%>");
       fail("Expected IllegalArgumentException");
-    } on IllegalArgumentException catch (exception) {}
+    } on IllegalArgumentException {}
   }
   void test_fromEncoding_noResolver() {
     SourceFactory factory = new SourceFactory([]);
     try {
       factory.fromEncoding("foo:/does/not/exist.dart");
       fail("Expected IllegalArgumentException");
-    } on IllegalArgumentException catch (exception) {}
+    } on IllegalArgumentException {}
   }
   void test_fromEncoding_valid() {
     String encoding = "file:///does/not/exist.dart";
     SourceFactory factory = new SourceFactory(
         [new UriResolver_SourceFactoryTest_test_fromEncoding_valid(encoding)]);
     expect(factory.fromEncoding(encoding), isNotNull);
   }
   void test_resolveUri_absolute() {
     UriResolver_absolute resolver = new UriResolver_absolute();
     SourceFactory factory = new SourceFactory([resolver]);
@@ skipping 522 matching lines @@
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }