New analyzer snapshot.

pkg/analyzer/lib/src/generated/constant.dart

 // 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';
 import 'source.dart' show Source;
 import 'error.dart' show AnalysisError, ErrorCode, CompileTimeErrorCode;
 import 'scanner.dart' show TokenType;
 import 'ast.dart';
@@ skipping 87 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(Object value) => new EvaluationResult(value, null);
 
   /**
    * The value of the expression.
    */
-  Object value;
+  final Object value;
 
   /**
    * The errors that should be reported for the expression(s) that were evaluated.
    */
   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(Object value, List<AnalysisError> errors) {
-    this.value = value;
+  EvaluationResult(this.value, List<AnalysisError> errors) {
     this._errors = 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 598 matching lines @@
 }
 
 /**
  * Instances of the class `ErrorResult` represent the result of evaluating an expression that
  * is not a valid compile time constant.
  */
 class ErrorResult extends EvaluationResultImpl {
   /**
    * The errors that prevent the expression from being a valid compile time constant.
    */
-  final List<ErrorResult_ErrorData> errorData = new List<ErrorResult_ErrorData>();
+  List<ErrorResult_ErrorData> _errors = new List<ErrorResult_ErrorData>();
 
   /**
    * Initialize a newly created result representing 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.con1(ASTNode node, ErrorCode errorCode) {
-    errorData.add(new ErrorResult_ErrorData(node, errorCode));
+    _errors.add(new ErrorResult_ErrorData(node, errorCode));
   }
 
   /**
    * Initialize a newly created result to represent the union of the errors in the given result
    * objects.
    *
    * @param firstResult the first set of results being merged
    * @param secondResult the second set of results being merged
    */
   ErrorResult.con2(ErrorResult firstResult, ErrorResult secondResult) {
-    errorData.addAll(firstResult.errorData);
-    errorData.addAll(secondResult.errorData);
+    _errors.addAll(firstResult._errors);
+    _errors.addAll(secondResult._errors);
   }
 
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToError(node, this);
 
   EvaluationResultImpl applyBooleanConversion(ASTNode node) => this;
 
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndError(node, this);
 
   EvaluationResultImpl bitNot(Expression node) => this;
 
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitOrError(node, this);
 
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitXorError(node, this);
 
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand) => rightOperand.concatenateError(node, this);
 
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.divideError(node, this);
 
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand) => rightOperand.equalEqualError(node, this);
 
   bool equalValues(EvaluationResultImpl result) => false;
 
+  List<ErrorResult_ErrorData> get errorData => _errors;
+
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanError(node, this);
 
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanOrEqualError(node, this);
 
   EvaluationResultImpl integerDivide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.integerDivideError(node, this);
 
   EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand) => this;
 
   EvaluationResultImpl lessThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanError(node, this);
 
@@ skipping 97 matching lines @@
 
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
 
   EvaluationResultImpl timesValid(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(BinaryExpression node, EvaluationResultImpl rightOperand);
 
   /**
@@ skipping 235 matching lines @@
   static ValidResult RESULT_STRING = new ValidResult("<string>");
 
   /**
    * A result object representing the value 'true'.
    */
   static ValidResult RESULT_TRUE = new ValidResult(true);
 
   /**
    * The value of the expression.
    */
-  Object value;
+  final Object value;
 
   /**
    * Initialize a newly created result to represent the given value.
    *
    * @param value the value of the expression
    */
-  ValidResult(Object value) {
-    this.value = value;
-  }
+  ValidResult(this.value);
 
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToValid(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
    */
   EvaluationResultImpl applyBooleanConversion(ASTNode node) => booleanConversion(node, value);
@@ skipping 772 matching lines @@
   ValidResult valueOf3(double value) => new ValidResult(value);
 
   /**
    * Return a result object representing the given value.
    *
    * @param value the value to be represented as a result object
    * @return a result object representing the given value
    */
   ValidResult valueOf4(String value) => new ValidResult(value);
 }