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

pkg/analyzer/lib/src/generated/constant.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.constant;
 
 import 'java_core.dart';
@@ skipping 48 matching lines @@
  * expressions that evaluate to a numeric value or to <b>null</b>.
  * * An expression of the form <i>e<sub>1</sub> ? e<sub>2</sub> : e<sub>3</sub></i> where
  * <i>e<sub>1</sub></i>, <i>e<sub>2</sub></i> and <i>e<sub>3</sub></i> are constant expressions, and
  * <i>e<sub>1</sub></i> evaluates to a boolean value.
  * </blockquote>
  */
 class ConstantEvaluator {
   /**
    * The source containing the expression(s) that will be evaluated.
    */
-  Source _source;
+  final Source _source;
 
   /**
    * The type provider used to access the known types.
    */
-  TypeProvider _typeProvider;
+  final TypeProvider _typeProvider;
 
   /**
    * Initialize a newly created evaluator to evaluate expressions in the given source.
    *
    * @param source the source containing the expression(s) that will be evaluated
    * @param typeProvider the type provider used to access known types
    */
-  ConstantEvaluator(Source source, TypeProvider typeProvider) {
-    this._source = source;
-    this._typeProvider = typeProvider;
-  }
+  ConstantEvaluator(this._source, this._typeProvider);
 
   EvaluationResult evaluate(Expression expression) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor(_typeProvider));
     if (result is ValidResult) {
       return EvaluationResult.forValue(result.value);
     }
     List<AnalysisError> errors = new List<AnalysisError>();
     for (ErrorResult_ErrorData data in (result as ErrorResult).errorData) {
       AstNode node = data.node;
       errors.add(new AnalysisError.con2(_source, node.offset, node.length, data.errorCode, []));
@@ skipping 103 matching lines @@
    * compile-time constant that evaluates to the given value.
    *
    * @param value the value of the expression
    * @return the result of evaluating an expression that is a compile-time constant
    */
   static EvaluationResult forValue(DartObject value) => new EvaluationResult(value, null);
 
   /**
    * The value of the expression.
    */
-  DartObject value;
+  final DartObject value;
 
   /**
    * The errors that should be reported for the expression(s) that were evaluated.
    */
-  List<AnalysisError> _errors;
+  final List<AnalysisError> _errors;
 
   /**
    * Initialize a newly created result object with the given state. Clients should use one of the
    * factory methods: [forErrors] and [forValue].
    *
    * @param value the value of the expression
    * @param errors the errors that should be reported for the expression(s) that were evaluated
    */
-  EvaluationResult(DartObject value, List<AnalysisError> errors) {
-    this.value = value;
-    this._errors = errors;
-  }
+  EvaluationResult(this.value, this._errors);
 
   /**
    * Return an array containing the errors that should be reported for the expression(s) that were
    * evaluated. If there are no such errors, the array will be empty. The array can be empty even if
    * the expression is not a valid compile time constant if the errors would have been reported by
    * other parts of the analysis engine.
    */
   List<AnalysisError> get errors => _errors == null ? AnalysisError.NO_ERRORS : _errors;
 
   /**
@@ skipping 34 matching lines @@
  * Instances of the class `ConstantValueComputer` compute the values of constant variables in
  * one or more compilation units. The expected usage pattern is for the compilation units to be
  * added to this computer using the method [add] and then for the method
  * [computeValues] to be invoked exactly once. Any use of an instance after invoking the
  * method [computeValues] will result in unpredictable behavior.
  */
 class ConstantValueComputer {
   /**
    * The type provider used to access the known types.
    */
-  TypeProvider _typeProvider;
+  final TypeProvider _typeProvider;
 
   /**
    * The object used to find constant variables in the compilation units that were added.
    */
   ConstantFinder _constantFinder = new ConstantFinder();
 
   /**
    * A graph in which the nodes are the constant variables and the edges are from each variable to
    * the other constant variables that are referenced in the head's initializer.
    */
   DirectedGraph<VariableElement> _referenceGraph = new DirectedGraph<VariableElement>();
 
   /**
    * A table mapping constant variables to the declarations of those variables.
    */
   Map<VariableElement, VariableDeclaration> _declarationMap;
 
   /**
    * Initialize a newly created constant value computer.
    *
    * @param typeProvider the type provider used to access known types
    */
-  ConstantValueComputer(TypeProvider typeProvider) {
-    this._typeProvider = typeProvider;
-  }
+  ConstantValueComputer(this._typeProvider);
 
   /**
    * Add the constant variables in the given compilation unit to the list of constant variables
    * whose value needs to be computed.
    *
    * @param unit the compilation unit defining the constant variables to be added
    */
   void add(CompilationUnit unit) {
     unit.accept(_constantFinder);
   }
@@ skipping 114 matching lines @@
  * expressions that evaluate to a numeric value or to <b>null</b>.
  * * An expression of the form <i>e<sub>1</sub> ? e<sub>2</sub> : e<sub>3</sub></i> where
  * <i>e<sub>1</sub></i>, <i>e<sub>2</sub></i> and <i>e<sub>3</sub></i> are constant expressions, and
  * <i>e<sub>1</sub></i> evaluates to a boolean value.
  * </blockquote>
  */
 class ConstantVisitor extends UnifyingAstVisitor<EvaluationResultImpl> {
   /**
    * The type provider used to access the known types.
    */
-  TypeProvider _typeProvider;
+  final TypeProvider _typeProvider;
 
   /**
    * An shared object representing the value 'null'.
    */
   DartObjectImpl _nullObject;
 
   /**
    * Initialize a newly created constant visitor.
    *
    * @param typeProvider the type provider used to access known types
    */
-  ConstantVisitor(TypeProvider typeProvider) {
-    this._typeProvider = typeProvider;
-  }
+  ConstantVisitor(this._typeProvider);
 
   @override
   EvaluationResultImpl visitAdjacentStrings(AdjacentStrings node) {
     EvaluationResultImpl result = null;
     for (StringLiteral string in node.strings) {
       if (result == null) {
         result = string.accept(this);
       } else {
         result = result.concatenate(_typeProvider, node, string.accept(this));
       }
@@ skipping 128 matching lines @@
             return _valid(definingClass, new SymbolState(argumentValue));
           }
         }
       }
       Map<String, DartObjectImpl> fieldMap = new Map<String, DartObjectImpl>();
       List<ParameterElement> parameters = constructor.parameters;
       int parameterCount = parameters.length;
       for (int i = 0; i < parameterCount; i++) {
         ParameterElement parameter = parameters[i];
         if (parameter.isInitializingFormal) {
-          String fieldName = (parameter as FieldFormalParameterElement).field.name;
-          if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
-            DartObjectImpl argumentValue = namedArgumentValues[parameter.name];
-            if (argumentValue != null) {
-              fieldMap[fieldName] = argumentValue;
+          FieldElement field = (parameter as FieldFormalParameterElement).field;
+          if (field != null) {
+            String fieldName = field.name;
+            if (parameter.parameterKind == ParameterKind.NAMED) {
+              DartObjectImpl argumentValue = namedArgumentValues[parameter.name];
+              if (argumentValue != null) {
+                fieldMap[fieldName] = argumentValue;
+              }
+            } else if (i < argumentCount) {
+              fieldMap[fieldName] = argumentValues[i];
             }
-          } else if (i < argumentCount) {
-            fieldMap[fieldName] = argumentValues[i];
           }
         }
       }
       // TODO(brianwilkerson) This doesn't handle fields initialized in an initializer. We should be
       // able to handle fields initialized by the superclass' constructor fairly easily, but other
       // initializers will be harder.
       return _valid(definingClass, new GenericState(fieldMap));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     return _error(node, null);
@@ skipping 498 matching lines @@
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
 
   @override
   EvaluationResultImpl timesValid(TypeProvider typeProvider, BinaryExpression node, ValidResult leftOperand) => this;
 }
 
 class ErrorResult_ErrorData {
   /**
    * The node against which the error should be reported.
    */
-  AstNode node;
+  final AstNode node;
 
   /**
    * The error code for the error to be generated.
    */
-  ErrorCode errorCode;
+  final ErrorCode errorCode;
 
   /**
    * Initialize a newly created data holder to represent the error with the given code reported
    * against the given node.
    *
    * @param node the node against which the error should be reported
    * @param errorCode the error code for the error to be generated
    */
-  ErrorResult_ErrorData(AstNode node, ErrorCode errorCode) {
-    this.node = node;
-    this.errorCode = errorCode;
-  }
+  ErrorResult_ErrorData(this.node, this.errorCode);
 }
 
 /**
  * Instances of the class `InternalResult` represent the result of attempting to evaluate a
  * expression.
  */
 abstract class EvaluationResultImpl {
   EvaluationResultImpl add(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand);
 
   /**
@@ skipping 135 matching lines @@
 }
 
 /**
  * Instances of the class `ReferenceFinder` add reference information for a given variable to
  * the bi-directional mapping used to order the evaluation of constants.
  */
 class ReferenceFinder extends RecursiveAstVisitor<Object> {
   /**
    * The element representing the variable whose initializer will be visited.
    */
-  VariableElement _source;
+  final VariableElement _source;
 
   /**
    * A graph in which the nodes are the constant variables and the edges are from each variable to
    * the other constant variables that are referenced in the head's initializer.
    */
-  DirectedGraph<VariableElement> _referenceGraph;
+  final DirectedGraph<VariableElement> _referenceGraph;
 
   /**
    * Initialize a newly created reference finder to find references from the given variable to other
    * variables and to add those references to the given graph.
    *
    * @param source the element representing the variable whose initializer will be visited
    * @param referenceGraph a graph recording which variables (heads) reference which other variables
    *          (tails) in their initializers
    */
-  ReferenceFinder(VariableElement source, DirectedGraph<VariableElement> referenceGraph) {
-    this._source = source;
-    this._referenceGraph = referenceGraph;
-  }
+  ReferenceFinder(this._source, this._referenceGraph);
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       if (variable.isConst) {
         _referenceGraph.addEdge(_source, variable);
       }
     }
     return null;
   }
 }
 
 /**
  * Instances of the class `ValidResult` represent the result of attempting to evaluate a valid
  * compile time constant expression.
  */
 class ValidResult extends EvaluationResultImpl {
   /**
    * The value of the expression.
    */
-  DartObjectImpl value;
+  final DartObjectImpl value;
 
   /**
    * Initialize a newly created result to represent the given value.
    *
    * @param value the value of the expression
    */
-  ValidResult(DartObjectImpl value) {
-    this.value = value;
-  }
+  ValidResult(this.value);
 
   @override
   EvaluationResultImpl add(TypeProvider typeProvider, BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToValid(typeProvider, node, this);
 
   /**
    * Return the result of applying boolean conversion to this result.
    *
    * @param node the node against which errors should be reported
    * @return the result of applying boolean conversion to the given value
    */
@@ skipping 417 matching lines @@
 }
 
 /**
  * Instances of the class `BoolState` represent the state of an object representing a boolean
  * value.
  */
 class BoolState extends InstanceState {
   /**
    * The value of this instance.
    */
-  bool value = false;
+  final bool value;
 
   /**
    * An instance representing the boolean value 'false'.
    */
   static BoolState FALSE_STATE = new BoolState(false);
 
   /**
    * An instance representing the boolean value 'true'.
    */
   static BoolState TRUE_STATE = new BoolState(true);
 
   /**
    * A state that can be used to represent a boolean whose value is not known.
    */
   static BoolState UNKNOWN_VALUE = new BoolState(null);
 
   /**
    * Return the boolean state representing the given boolean value.
    *
    * @param value the value to be represented
    * @return the boolean state representing the given boolean value
    */
   static BoolState from(bool value) => value ? BoolState.TRUE_STATE : BoolState.FALSE_STATE;
 
   /**
    * Initialize a newly created state to represent the given value.
    *
    * @param value the value of this instance
    */
-  BoolState(bool value) {
-    this.value = value;
-  }
+  BoolState(this.value);
 
   @override
   BoolState convertToBool() => this;
 
   @override
   StringState convertToString() {
     if (value == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(value ? "true" : "false");
@@ skipping 70 matching lines @@
   String toString() => value == null ? "-unknown-" : (value ? "true" : "false");
 }
 
 /**
  * Instances of the class `DartObjectImpl` represent an instance of a Dart class.
  */
 class DartObjectImpl implements DartObject {
   /**
    * The run-time type of this object.
    */
-  InterfaceType type;
+  final InterfaceType type;
 
   /**
    * The state of the object.
    */
-  InstanceState _state;
+  final InstanceState _state;
 
   /**
    * Initialize a newly created object to have the given type and state.
    *
    * @param type the run-time type of this object
    * @param state the state of the object
    */
-  DartObjectImpl(InterfaceType type, InstanceState state) {
-    this.type = type;
-    this._state = state;
-  }
+  DartObjectImpl(this.type, this._state);
 
   /**
    * Return the result of invoking the '+' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '+' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl add(TypeProvider typeProvider, DartObjectImpl rightOperand) {
@@ skipping 413 matching lines @@
 }
 
 /**
  * Instances of the class `DoubleState` represent the state of an object representing a
  * double.
  */
 class DoubleState extends NumState {
   /**
    * The value of this instance.
    */
-  double value = 0.0;
+  final double value;
 
   /**
    * A state that can be used to represent a double whose value is not known.
    */
   static DoubleState UNKNOWN_VALUE = new DoubleState(null);
 
   /**
    * Initialize a newly created state to represent a double with the given value.
    *
    * @param value the value of this instance
    */
-  DoubleState(double value) {
-    this.value = value;
-  }
+  DoubleState(this.value);
 
   @override
   NumState add(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     if (value == null) {
       return UNKNOWN_VALUE;
     }
     if (rightOperand is IntState) {
       int rightValue = rightOperand.value;
       if (rightValue == null) {
@@ skipping 455 matching lines @@
 }
 
 /**
  * Instances of the class `EvaluationException` represent a run-time exception that would be
  * thrown during the evaluation of Dart code.
  */
 class EvaluationException extends JavaException {
   /**
    * The error code associated with the exception.
    */
-  ErrorCode errorCode;
+  final ErrorCode errorCode;
 
   /**
    * Initialize a newly created exception to have the given error code.
    *
    * @param errorCode the error code associated with the exception
    */
-  EvaluationException(ErrorCode errorCode) {
-    this.errorCode = errorCode;
-  }
+  EvaluationException(this.errorCode);
 }
 
 /**
  * Instances of the class `FunctionState` represent the state of an object representing a
  * function.
  */
 class FunctionState extends InstanceState {
   /**
    * The element representing the function being modeled.
    */
-  ExecutableElement _element;
+  final ExecutableElement _element;
 
   /**
    * Initialize a newly created state to represent the given function.
    *
    * @param element the element representing the function being modeled
    */
-  FunctionState(ExecutableElement element) {
-    this._element = element;
-  }
+  FunctionState(this._element);
 
   @override
   StringState convertToString() {
     if (_element == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(_element.name);
   }
 
   @override
@@ skipping 27 matching lines @@
 }
 
 /**
  * Instances of the class `GenericState` represent the state of an object representing a Dart
  * object for which there is no more specific state.
  */
 class GenericState extends InstanceState {
   /**
    * The values of the fields of this instance.
    */
-  Map<String, DartObjectImpl> _fieldMap = new Map<String, DartObjectImpl>();
+  final Map<String, DartObjectImpl> _fieldMap;
 
   /**
    * A state that can be used to represent an object whose state is not known.
    */
   static GenericState UNKNOWN_VALUE = new GenericState(new Map<String, DartObjectImpl>());
 
   /**
    * Initialize a newly created state to represent a newly created object.
    *
    * @param fieldMap the values of the fields of this instance
    */
-  GenericState(Map<String, DartObjectImpl> fieldMap) {
-    this._fieldMap = fieldMap;
-  }
+  GenericState(this._fieldMap);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   bool operator ==(Object object) {
     if (object is! GenericState) {
       return false;
     }
     GenericState state = object as GenericState;
@@ skipping 433 matching lines @@
   }
 }
 
 /**
  * Instances of the class `IntState` represent the state of an object representing an int.
  */
 class IntState extends NumState {
   /**
    * The value of this instance.
    */
-  int value = 0;
+  final int value;
 
   /**
    * A state that can be used to represent an int whose value is not known.
    */
   static IntState UNKNOWN_VALUE = new IntState(null);
 
   /**
    * Initialize a newly created state to represent an int with the given value.
    *
    * @param value the value of this instance
    */
-  IntState(int value) {
-    this.value = value;
-  }
+  IntState(this.value);
 
   @override
   NumState add(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     if (value == null) {
       if (rightOperand is DoubleState) {
         return DoubleState.UNKNOWN_VALUE;
       }
       return UNKNOWN_VALUE;
     }
@@ skipping 412 matching lines @@
 }
 
 /**
  * The unique instance of the class `ListState` represents the state of an object representing
  * a list.
  */
 class ListState extends InstanceState {
   /**
    * The elements of the list.
    */
-  List<DartObjectImpl> _elements;
+  final List<DartObjectImpl> _elements;
 
   /**
    * Initialize a newly created state to represent a list with the given elements.
    *
    * @param elements the elements of the list
    */
-  ListState(List<DartObjectImpl> elements) {
-    this._elements = elements;
-  }
+  ListState(this._elements);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
@@ skipping 60 matching lines @@
 }
 
 /**
  * The unique instance of the class `ListState` represents the state of an object representing
  * a map.
  */
 class MapState extends InstanceState {
   /**
    * The entries in the map.
    */
-  Map<DartObjectImpl, DartObjectImpl> _entries;
+  final Map<DartObjectImpl, DartObjectImpl> _entries;
 
   /**
    * Initialize a newly created state to represent a map with the given entries.
    *
    * @param entries the entries in the map
    */
-  MapState(Map<DartObjectImpl, DartObjectImpl> entries) {
-    this._entries = entries;
-  }
+  MapState(this._entries);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
@@ skipping 219 matching lines @@
 }
 
 /**
  * Instances of the class `StringState` represent the state of an object representing a
  * string.
  */
 class StringState extends InstanceState {
   /**
    * The value of this instance.
    */
-  String value;
+  final String value;
 
   /**
    * A state that can be used to represent a double whose value is not known.
    */
   static StringState UNKNOWN_VALUE = new StringState(null);
 
   /**
    * Initialize a newly created state to represent the given value.
    *
    * @param value the value of this instance
    */
-  StringState(String value) {
-    this.value = value;
-  }
+  StringState(this.value);
 
   @override
   StringState concatenate(InstanceState rightOperand) {
     if (value == null) {
       return UNKNOWN_VALUE;
     }
     if (rightOperand is StringState) {
       String rightValue = rightOperand.value;
       if (rightValue == null) {
         return UNKNOWN_VALUE;
@@ skipping 46 matching lines @@
 }
 
 /**
  * Instances of the class `StringState` represent the state of an object representing a
  * symbol.
  */
 class SymbolState extends InstanceState {
   /**
    * The value of this instance.
    */
-  String value;
+  final String value;
 
   /**
    * Initialize a newly created state to represent the given value.
    *
    * @param value the value of this instance
    */
-  SymbolState(String value) {
-    this.value = value;
-  }
+  SymbolState(this.value);
 
   @override
   StringState convertToString() {
     if (value == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(value);
   }
 
   @override
@@ skipping 30 matching lines @@
   String toString() => value == null ? "-unknown-" : "#${value}";
 }
 
 /**
  * Instances of the class `TypeState` represent the state of an object representing a type.
  */
 class TypeState extends InstanceState {
   /**
    * The element representing the type being modeled.
    */
-  Element _element;
+  final Element _element;
 
   /**
    * Initialize a newly created state to represent the given value.
    *
    * @param element the element representing the type being modeled
    */
-  TypeState(Element element) {
-    this._element = element;
-  }
+  TypeState(this._element);
 
   @override
   StringState convertToString() {
     if (_element == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(_element.name);
   }
 
   @override
@@ skipping 19 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }