Fix for translation of \!= to \!identical(), but use == and \!= for Enum.

pkg/analyzer/test/generated/ast_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.ast_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 800 matching lines @@
 
   void test_inDeclarationContext_variableDeclaration() {
     SimpleIdentifier identifier = AstFactory.variableDeclaration("v").name;
     JUnitTestCase.assertTrue(identifier.inDeclarationContext());
   }
 
   void test_inGetterContext() {
     for (WrapperKind wrapper in WrapperKind.values) {
       for (AssignmentKind assignment in AssignmentKind.values) {
         SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
-        if (identical(assignment, AssignmentKind.SIMPLE_LEFT) && wrapper != WrapperKind.PREFIXED_LEFT && wrapper != WrapperKind.PROPERTY_LEFT) {
+        if (assignment == AssignmentKind.SIMPLE_LEFT && wrapper != WrapperKind.PREFIXED_LEFT && wrapper != WrapperKind.PROPERTY_LEFT) {
           if (identifier.inGetterContext()) {
             JUnitTestCase.fail("Expected ${_topMostNode(identifier).toSource()} to be false");
           }
         } else {
           if (!identifier.inGetterContext()) {
             JUnitTestCase.fail("Expected ${_topMostNode(identifier).toSource()} to be true");
           }
         }
       }
     }
   }
 
   void test_inReferenceContext() {
     SimpleIdentifier identifier = AstFactory.identifier3("id");
     AstFactory.namedExpression(AstFactory.label(identifier), AstFactory.identifier3("_"));
     JUnitTestCase.assertFalse(identifier.inGetterContext());
     JUnitTestCase.assertFalse(identifier.inSetterContext());
   }
 
   void test_inSetterContext() {
     for (WrapperKind wrapper in WrapperKind.values) {
       for (AssignmentKind assignment in AssignmentKind.values) {
         SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
-        if (identical(wrapper, WrapperKind.PREFIXED_LEFT) || identical(wrapper, WrapperKind.PROPERTY_LEFT) || identical(assignment, AssignmentKind.BINARY) || identical(assignment, AssignmentKind.COMPOUND_RIGHT) || identical(assignment, AssignmentKind.PREFIX_NOT) || identical(assignment, AssignmentKind.SIMPLE_RIGHT) || identical(assignment, AssignmentKind.NONE)) {
+        if (wrapper == WrapperKind.PREFIXED_LEFT || wrapper == WrapperKind.PROPERTY_LEFT || assignment == AssignmentKind.BINARY || assignment == AssignmentKind.COMPOUND_RIGHT || assignment == AssignmentKind.PREFIX_NOT || assignment == AssignmentKind.SIMPLE_RIGHT || assignment == AssignmentKind.NONE) {
           if (identifier.inSetterContext()) {
             JUnitTestCase.fail("Expected ${_topMostNode(identifier).toSource()} to be false");
           }
         } else {
           if (!identifier.inSetterContext()) {
             JUnitTestCase.fail("Expected ${_topMostNode(identifier).toSource()} to be true");
           }
         }
       }
     }
@@ skipping 137 matching lines @@
       });
       _ut.test('test_inSetterContext', () {
         final __test = new SimpleIdentifierTest();
         runJUnitTest(__test, __test.test_inSetterContext);
       });
     });
   }
 }
 
 class AssignmentKind extends Enum<AssignmentKind> {
-  static final AssignmentKind BINARY = new AssignmentKind('BINARY', 0);
+  static const AssignmentKind BINARY = const AssignmentKind('BINARY', 0);
 
-  static final AssignmentKind COMPOUND_LEFT = new AssignmentKind('COMPOUND_LEFT', 1);
+  static const AssignmentKind COMPOUND_LEFT = const AssignmentKind('COMPOUND_LEFT', 1);
 
-  static final AssignmentKind COMPOUND_RIGHT = new AssignmentKind('COMPOUND_RIGHT', 2);
+  static const AssignmentKind COMPOUND_RIGHT = const AssignmentKind('COMPOUND_RIGHT', 2);
 
-  static final AssignmentKind POSTFIX_INC = new AssignmentKind('POSTFIX_INC', 3);
+  static const AssignmentKind POSTFIX_INC = const AssignmentKind('POSTFIX_INC', 3);
 
-  static final AssignmentKind PREFIX_DEC = new AssignmentKind('PREFIX_DEC', 4);
+  static const AssignmentKind PREFIX_DEC = const AssignmentKind('PREFIX_DEC', 4);
 
-  static final AssignmentKind PREFIX_INC = new AssignmentKind('PREFIX_INC', 5);
+  static const AssignmentKind PREFIX_INC = const AssignmentKind('PREFIX_INC', 5);
 
-  static final AssignmentKind PREFIX_NOT = new AssignmentKind('PREFIX_NOT', 6);
+  static const AssignmentKind PREFIX_NOT = const AssignmentKind('PREFIX_NOT', 6);
 
-  static final AssignmentKind SIMPLE_LEFT = new AssignmentKind('SIMPLE_LEFT', 7);
+  static const AssignmentKind SIMPLE_LEFT = const AssignmentKind('SIMPLE_LEFT', 7);
 
-  static final AssignmentKind SIMPLE_RIGHT = new AssignmentKind('SIMPLE_RIGHT', 8);
+  static const AssignmentKind SIMPLE_RIGHT = const AssignmentKind('SIMPLE_RIGHT', 8);
 
-  static final AssignmentKind NONE = new AssignmentKind('NONE', 9);
+  static const AssignmentKind NONE = const AssignmentKind('NONE', 9);
 
-  static final List<AssignmentKind> values = [
+  static const List<AssignmentKind> values = const [
       BINARY,
       COMPOUND_LEFT,
       COMPOUND_RIGHT,
       POSTFIX_INC,
       PREFIX_DEC,
       PREFIX_INC,
       PREFIX_NOT,
       SIMPLE_LEFT,
       SIMPLE_RIGHT,
       NONE];
 
-  AssignmentKind(String name, int ordinal) : super(name, ordinal);
+  const AssignmentKind(String name, int ordinal) : super(name, ordinal);
 }
 
 class WrapperKind extends Enum<WrapperKind> {
-  static final WrapperKind PREFIXED_LEFT = new WrapperKind('PREFIXED_LEFT', 0);
+  static const WrapperKind PREFIXED_LEFT = const WrapperKind('PREFIXED_LEFT', 0);
 
-  static final WrapperKind PREFIXED_RIGHT = new WrapperKind('PREFIXED_RIGHT', 1);
+  static const WrapperKind PREFIXED_RIGHT = const WrapperKind('PREFIXED_RIGHT', 1);
 
-  static final WrapperKind PROPERTY_LEFT = new WrapperKind('PROPERTY_LEFT', 2);
+  static const WrapperKind PROPERTY_LEFT = const WrapperKind('PROPERTY_LEFT', 2);
 
-  static final WrapperKind PROPERTY_RIGHT = new WrapperKind('PROPERTY_RIGHT', 3);
+  static const WrapperKind PROPERTY_RIGHT = const WrapperKind('PROPERTY_RIGHT', 3);
 
-  static final WrapperKind NONE = new WrapperKind('NONE', 4);
+  static const WrapperKind NONE = const WrapperKind('NONE', 4);
 
-  static final List<WrapperKind> values = [
+  static const List<WrapperKind> values = const [
       PREFIXED_LEFT,
       PREFIXED_RIGHT,
       PROPERTY_LEFT,
       PROPERTY_RIGHT,
       NONE];
 
-  WrapperKind(String name, int ordinal) : super(name, ordinal);
+  const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }
 
 class BreadthFirstVisitorTest extends ParserTestCase {
   void testIt() {
     String source = EngineTestCase.createSource([
         "class A {",
         "  bool get g => true;",
         "}",
         "class B {",
         "  int f() {",
@@ skipping 3172 matching lines @@
   NodeLocatorTest.dartSuite();
   ToSourceVisitorTest.dartSuite();
   BreadthFirstVisitorTest.dartSuite();
   ClassDeclarationTest.dartSuite();
   IndexExpressionTest.dartSuite();
   NodeListTest.dartSuite();
   SimpleIdentifierTest.dartSuite();
   SimpleStringLiteralTest.dartSuite();
   VariableDeclarationTest.dartSuite();
 }