java2dart improvement - use field if getter/setter are trivial.

pkg/analyzer_experimental/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';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 84 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;
+  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;
+    this.value = value;
     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;
 
   /**
-   * Return the value of the expression, or `null` if the expression evaluated to `null`
-   * or if the expression could not be evaluated, either because it was not a compile-time constant
-   * expression or because it would throw an exception when evaluated.
-   *
-   * @return the value of the expression
-   */
-  Object get value => _value;
-
-  /**
    * Return `true` if the expression is a compile-time constant expression that would not
    * throw an exception when evaluated.
    *
    * @return `true` if the expression is a valid compile-time constant expression
    */
   bool get isValid => _errors == null;
 }
 /**
  * Instances of the class `ConstantFinder` are used to traverse the AST structures of all of
  * the compilation units being resolved and build a table mapping constant variable elements to the
  * declarations of those variables.
  */
 class ConstantFinder extends RecursiveASTVisitor<Object> {
 
   /**
    * A table mapping constant variable elements to the declarations of those variables.
    */
-  Map<VariableElement, VariableDeclaration> _variableMap = new Map<VariableElement, VariableDeclaration>();
-
-  /**
-   * Return a table mapping constant variable elements to the declarations of those variables.
-   *
-   * @return a table mapping constant variable elements to the declarations of those variables
-   */
-  Map<VariableElement, VariableDeclaration> get variableMap => _variableMap;
+  final Map<VariableElement, VariableDeclaration> variableMap = new Map<VariableElement, VariableDeclaration>();
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     if (initializer != null && node.isConst) {
       VariableElement element = node.element;
       if (element != null) {
-        _variableMap[element] = node;
+        variableMap[element] = node;
       }
     }
     return null;
   }
 }
 /**
  * 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 invoked exactly once. Any use of an instance after invoking the
@@ skipping 519 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.
    */
-  List<ErrorResult_ErrorData> _errors = new List<ErrorResult_ErrorData>();
+  final List<ErrorResult_ErrorData> errorData = 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) {
-    _errors.add(new ErrorResult_ErrorData(node, errorCode));
+    errorData.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) {
-    _errors.addAll(firstResult._errors);
-    _errors.addAll(secondResult._errors);
+    errorData.addAll(firstResult.errorData);
+    errorData.addAll(secondResult.errorData);
   }
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToError(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);
   EvaluationResultImpl lessThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanOrEqualError(node, this);
   EvaluationResultImpl logicalAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalAndError(node, this);
   EvaluationResultImpl logicalNot(Expression node) => this;
   EvaluationResultImpl logicalOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalOrError(node, this);
   EvaluationResultImpl minus(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.minusError(node, this);
@@ skipping 42 matching lines @@
   EvaluationResultImpl shiftRightError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
   EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand) => this;
   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;
+  ASTNode node;
 
   /**
    * The error code for the error to be generated.
    */
-  ErrorCode _errorCode;
+  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;
+    this.node = node;
+    this.errorCode = errorCode;
   }
-
-  /**
-   * Return the error code for the error to be generated.
-   *
-   * @return the error code for the error to be generated
-   */
-  ErrorCode get errorCode => _errorCode;
-
-  /**
-   * Return the node against which the error should be reported.
-   *
-   * @return the node against which the error should be reported
-   */
-  ASTNode get node => _node;
 }
 /**
  * Instances of the class `InternalResult` represent the result of attempting to evaluate a
  * expression.
  */
 abstract class EvaluationResultImpl {
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand);
   EvaluationResultImpl bitNot(Expression node);
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand);
@@ skipping 155 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;
+  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;
+    this.value = value;
   }
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.addToValid(node, this);
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndValid(node, this);
   EvaluationResultImpl bitNot(Expression node) {
     if (isSomeInt) {
       return RESULT_INT;
     }
-    if (_value == null) {
+    if (value == null) {
       return error(node);
-    } else if (_value is int) {
-      return valueOf(~((_value as int)));
+    } else if (value is int) {
+      return valueOf(~((value as int)));
     }
     return error(node);
   }
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitOrValid(node, this);
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitXorValid(node, this);
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand) => rightOperand.concatenateValid(node, this);
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.divideValid(node, this);
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand) => rightOperand.equalEqualValid(node, this);
   bool equalValues(EvaluationResultImpl result) => identical(equalEqual(null, result), RESULT_TRUE);
-  Object get value => _value;
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanValid(node, this);
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.greaterThanOrEqualValid(node, this);
   EvaluationResultImpl integerDivide(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.integerDivideValid(node, this);
   EvaluationResultImpl lessThan(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanValid(node, this);
   EvaluationResultImpl lessThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.lessThanOrEqualValid(node, this);
   EvaluationResultImpl logicalAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalAndValid(node, this);
   EvaluationResultImpl logicalNot(Expression node) {
     if (isSomeBool) {
       return RESULT_BOOL;
     }
-    if (_value == null) {
+    if (value == null) {
       return RESULT_TRUE;
-    } else if (_value is bool) {
-      return ((_value as bool)) ? RESULT_FALSE : RESULT_TRUE;
+    } else if (value is bool) {
+      return ((value as bool)) ? RESULT_FALSE : RESULT_TRUE;
     }
     return error(node);
   }
   EvaluationResultImpl logicalOr(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.logicalOrValid(node, this);
   EvaluationResultImpl minus(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.minusValid(node, this);
   EvaluationResultImpl negated(Expression node) {
     if (isSomeNum) {
       return RESULT_INT;
     }
-    if (_value == null) {
+    if (value == null) {
       return error(node);
-    } else if (_value is int) {
-      return valueOf(-((_value as int)));
-    } else if (_value is double) {
-      return valueOf3(-((_value as double)));
+    } else if (value is int) {
+      return valueOf(-((value as int)));
+    } else if (value is double) {
+      return valueOf3(-((value as double)));
     }
     return error(node);
   }
   EvaluationResultImpl notEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.notEqualValid(node, this);
   EvaluationResultImpl performToString(ASTNode node) {
-    if (_value == null) {
+    if (value == null) {
       return valueOf4("null");
-    } else if (_value is bool) {
-      return valueOf4(((_value as bool)).toString());
-    } else if (_value is int) {
-      return valueOf4(((_value as int)).toString());
-    } else if (_value is double) {
-      return valueOf4(((_value as double)).toString());
-    } else if (_value is String) {
+    } else if (value is bool) {
+      return valueOf4(((value as bool)).toString());
+    } else if (value is int) {
+      return valueOf4(((value as int)).toString());
+    } else if (value is double) {
+      return valueOf4(((value as double)).toString());
+    } else if (value is String) {
       return this;
     }
     return error(node);
   }
   EvaluationResultImpl remainder(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.remainderValid(node, this);
   EvaluationResultImpl shiftLeft(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftLeftValid(node, this);
   EvaluationResultImpl shiftRight(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftRightValid(node, this);
   EvaluationResultImpl times(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.timesValid(node, this);
   String toString() {
-    if (_value == null) {
+    if (value == null) {
       return "null";
     }
-    return _value.toString();
+    return value.toString();
   }
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) + (_value as int));
-      } else if (_value is double) {
-        return valueOf3(((leftValue as int)).toDouble() + ((_value as double)));
+      if (value is int) {
+        return valueOf(((leftValue as int)) + (value as int));
+      } else if (value is double) {
+        return valueOf3(((leftValue as int)).toDouble() + ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf3(((leftValue as double)) + ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf3(((leftValue as double)) + ((_value as double)));
+      if (value is int) {
+        return valueOf3(((leftValue as double)) + ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf3(((leftValue as double)) + ((value as double)));
       }
     } else if (leftValue is String) {
-      if (_value is String) {
-        return valueOf4("${((leftValue as String))}${((_value as String))}");
+      if (value is String) {
+        return valueOf4("${((leftValue as String))}${((value as String))}");
       }
     }
     return error(node);
   }
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyInt || !leftOperand2.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) & (_value as int));
+      if (value is int) {
+        return valueOf(((leftValue as int)) & (value as int));
       }
       return error(node.leftOperand);
     }
-    if (_value is int) {
+    if (value is int) {
       return error(node.rightOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl bitOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyInt || !leftOperand2.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) | (_value as int));
+      if (value is int) {
+        return valueOf(((leftValue as int)) | (value as int));
       }
       return error(node.leftOperand);
     }
-    if (_value is int) {
+    if (value is int) {
       return error(node.rightOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl bitXorError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyInt || !leftOperand2.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) ^ (_value as int));
+      if (value is int) {
+        return valueOf(((leftValue as int)) ^ (value as int));
       }
       return error(node.leftOperand);
     }
-    if (_value is int) {
+    if (value is int) {
       return error(node.rightOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl concatenateError(Expression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl concatenateValid(Expression node, ValidResult leftOperand) {
     Object leftValue = leftOperand.value;
-    if (leftValue is String && _value is String) {
-      return valueOf4("${((leftValue as String))}${((_value as String))}");
+    if (leftValue is String && value is String) {
+      return valueOf4("${((leftValue as String))}${((value as String))}");
     }
     return error(node);
   }
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        if (((_value as int)) == 0) {
-          return valueOf3(((leftValue as int)).toDouble() / ((_value as int)).toDouble());
+      if (value is int) {
+        if (((value as int)) == 0) {
+          return valueOf3(((leftValue as int)).toDouble() / ((value as int)).toDouble());
         }
-        return valueOf(((leftValue as int)) ~/ (_value as int));
-      } else if (_value is double) {
-        return valueOf3(((leftValue as int)).toDouble() / ((_value as double)));
+        return valueOf(((leftValue as int)) ~/ (value as int));
+      } else if (value is double) {
+        return valueOf3(((leftValue as int)).toDouble() / ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf3(((leftValue as double)) / ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf3(((leftValue as double)) / ((_value as double)));
+      if (value is int) {
+        return valueOf3(((leftValue as double)) / ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf3(((leftValue as double)) / ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl equalEqualError(Expression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl equalEqualValid(Expression node, ValidResult leftOperand) {
     if (node is BinaryExpression) {
       if (!isAnyNullBoolNumString || !leftOperand.isAnyNullBoolNumString) {
         return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
       }
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
-      return valueOf2(_value == null);
+      return valueOf2(value == null);
     } else if (leftValue is bool) {
-      if (_value is bool) {
-        return valueOf2(identical(leftValue as bool, _value as bool));
+      if (value is bool) {
+        return valueOf2(identical(leftValue as bool, value as bool));
       }
       return RESULT_FALSE;
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)) == _value);
-      } else if (_value is double) {
-        return valueOf2(toDouble(leftValue as int) == _value);
+      if (value is int) {
+        return valueOf2(((leftValue as int)) == value);
+      } else if (value is double) {
+        return valueOf2(toDouble(leftValue as int) == value);
       }
       return RESULT_FALSE;
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) == toDouble(_value as int));
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) == _value);
+      if (value is int) {
+        return valueOf2(((leftValue as double)) == toDouble(value as int));
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) == value);
       }
       return RESULT_FALSE;
     } else if (leftValue is String) {
-      if (_value is String) {
-        return valueOf2(((leftValue as String)) == _value);
+      if (value is String) {
+        return valueOf2(((leftValue as String)) == value);
       }
       return RESULT_FALSE;
     }
     return RESULT_FALSE;
   }
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)).compareTo(_value as int) >= 0);
-      } else if (_value is double) {
-        return valueOf2(((leftValue as int)).toDouble() >= ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as int)).compareTo(value as int) >= 0);
+      } else if (value is double) {
+        return valueOf2(((leftValue as int)).toDouble() >= ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) >= ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) >= ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as double)) >= ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) >= ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)).compareTo(_value as int) > 0);
-      } else if (_value is double) {
-        return valueOf2(((leftValue as int)).toDouble() > ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as int)).compareTo(value as int) > 0);
+      } else if (value is double) {
+        return valueOf2(((leftValue as int)).toDouble() > ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) > ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) > ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as double)) > ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) > ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        if (((_value as int)) == 0) {
+      if (value is int) {
+        if (((value as int)) == 0) {
           return error2(node, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE);
         }
-        return valueOf(((leftValue as int)) ~/ (_value as int));
-      } else if (_value is double) {
-        double result = ((leftValue as int)).toDouble() / ((_value as double));
+        return valueOf(((leftValue as int)) ~/ (value as int));
+      } else if (value is double) {
+        double result = ((leftValue as int)).toDouble() / ((value as double));
         return valueOf(result.toInt());
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        double result = ((leftValue as double)) / ((_value as int)).toDouble();
+      if (value is int) {
+        double result = ((leftValue as double)) / ((value as int)).toDouble();
         return valueOf(result.toInt());
-      } else if (_value is double) {
-        double result = ((leftValue as double)) / ((_value as double));
+      } else if (value is double) {
+        double result = ((leftValue as double)) / ((value as double));
         return valueOf(result.toInt());
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)).compareTo(_value as int) <= 0);
-      } else if (_value is double) {
-        return valueOf2(((leftValue as int)).toDouble() <= ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as int)).compareTo(value as int) <= 0);
+      } else if (value is double) {
+        return valueOf2(((leftValue as int)).toDouble() <= ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) <= ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) <= ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as double)) <= ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) <= ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)).compareTo(_value as int) < 0);
-      } else if (_value is double) {
-        return valueOf2(((leftValue as int)).toDouble() < ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as int)).compareTo(value as int) < 0);
+      } else if (value is double) {
+        return valueOf2(((leftValue as int)).toDouble() < ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) < ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) < ((_value as double)));
+      if (value is int) {
+        return valueOf2(((leftValue as double)) < ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) < ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl logicalAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl logicalAndValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyBool || !leftOperand.isAnyBool) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL);
     }
     if (isSomeBool || leftOperand.isSomeBool) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue is bool) {
       if (((leftValue as bool))) {
-        return booleanConversion(node.rightOperand, _value);
+        return booleanConversion(node.rightOperand, value);
       }
       return RESULT_FALSE;
     }
     return error(node);
   }
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl logicalOrValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyBool || !leftOperand.isAnyBool) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL);
     }
     if (isSomeBool || leftOperand.isSomeBool) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue is bool && ((leftValue as bool))) {
       return RESULT_TRUE;
     }
-    return booleanConversion(node.rightOperand, _value);
+    return booleanConversion(node.rightOperand, value);
   }
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) - (_value as int));
-      } else if (_value is double) {
-        return valueOf3(((leftValue as int)).toDouble() - ((_value as double)));
+      if (value is int) {
+        return valueOf(((leftValue as int)) - (value as int));
+      } else if (value is double) {
+        return valueOf3(((leftValue as int)).toDouble() - ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf3(((leftValue as double)) - ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf3(((leftValue as double)) - ((_value as double)));
+      if (value is int) {
+        return valueOf3(((leftValue as double)) - ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf3(((leftValue as double)) - ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl notEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl notEqualValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNullBoolNumString || !leftOperand.isAnyNullBoolNumString) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
-      return valueOf2(_value != null);
+      return valueOf2(value != null);
     } else if (leftValue is bool) {
-      if (_value is bool) {
-        return valueOf2(((leftValue as bool)) != ((_value as bool)));
+      if (value is bool) {
+        return valueOf2(((leftValue as bool)) != ((value as bool)));
       }
       return RESULT_TRUE;
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf2(((leftValue as int)) != _value);
-      } else if (_value is double) {
-        return valueOf2(toDouble(leftValue as int) != _value);
+      if (value is int) {
+        return valueOf2(((leftValue as int)) != value);
+      } else if (value is double) {
+        return valueOf2(toDouble(leftValue as int) != value);
       }
       return RESULT_TRUE;
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf2(((leftValue as double)) != toDouble(_value as int));
-      } else if (_value is double) {
-        return valueOf2(((leftValue as double)) != _value);
+      if (value is int) {
+        return valueOf2(((leftValue as double)) != toDouble(value as int));
+      } else if (value is double) {
+        return valueOf2(((leftValue as double)) != value);
       }
       return RESULT_TRUE;
     } else if (leftValue is String) {
-      if (_value is String) {
-        return valueOf2(((leftValue as String)) != _value);
+      if (value is String) {
+        return valueOf2(((leftValue as String)) != value);
       }
       return RESULT_TRUE;
     }
     return RESULT_TRUE;
   }
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        if (((_value as int)) == 0) {
-          return valueOf3(((leftValue as int)).toDouble() % ((_value as int)).toDouble());
+      if (value is int) {
+        if (((value as int)) == 0) {
+          return valueOf3(((leftValue as int)).toDouble() % ((value as int)).toDouble());
         }
-        return valueOf(((leftValue as int)).remainder(_value as int));
-      } else if (_value is double) {
-        return valueOf3(((leftValue as int)).toDouble() % ((_value as double)));
+        return valueOf(((leftValue as int)).remainder(value as int));
+      } else if (value is double) {
+        return valueOf3(((leftValue as int)).toDouble() % ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf3(((leftValue as double)) % ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf3(((leftValue as double)) % ((_value as double)));
+      if (value is int) {
+        return valueOf3(((leftValue as double)) % ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf3(((leftValue as double)) % ((value as double)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyInt || !leftOperand2.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) << ((_value as int)));
+      if (value is int) {
+        return valueOf(((leftValue as int)) << ((value as int)));
       }
       return error(node.rightOperand);
     }
-    if (_value is int) {
+    if (value is int) {
       return error(node.leftOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl shiftRightError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyInt || !leftOperand2.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) >> ((_value as int)));
+      if (value is int) {
+        return valueOf(((leftValue as int)) >> ((value as int)));
       }
       return error(node.rightOperand);
     }
-    if (_value is int) {
+    if (value is int) {
       return error(node.leftOperand);
     }
     return union(error(node.leftOperand), error(node.rightOperand));
   }
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl timesValid(BinaryExpression node, ValidResult leftOperand2) {
     if (!isAnyNum || !leftOperand2.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand2.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand2.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand2.value;
     if (leftValue == null) {
       return error(node.leftOperand);
-    } else if (_value == null) {
+    } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
-      if (_value is int) {
-        return valueOf(((leftValue as int)) * (_value as int));
-      } else if (_value is double) {
-        return valueOf3(((leftValue as int)).toDouble() * ((_value as double)));
+      if (value is int) {
+        return valueOf(((leftValue as int)) * (value as int));
+      } else if (value is double) {
+        return valueOf3(((leftValue as int)).toDouble() * ((value as double)));
       }
     } else if (leftValue is double) {
-      if (_value is int) {
-        return valueOf3(((leftValue as double)) * ((_value as int)).toDouble());
-      } else if (_value is double) {
-        return valueOf3(((leftValue as double)) * ((_value as double)));
+      if (value is int) {
+        return valueOf3(((leftValue as double)) * ((value as int)).toDouble());
+      } else if (value is double) {
+        return valueOf3(((leftValue as double)) * ((value as double)));
       }
     }
     return error(node);
   }
   bool get isNull => identical(this, RESULT_NULL);
 
   /**
    * Return the result of applying boolean conversion to the given value.
    *
    * @param node the node against which errors should be reported
@@ skipping 22 matching lines @@
   ErrorResult error2(ASTNode node, ErrorCode code) => new ErrorResult.con1(node, code);
 
   /**
    * Checks if this result has type "bool", with known or unknown value.
    */
   bool get isAnyBool => isSomeBool || identical(this, RESULT_TRUE) || identical(this, RESULT_FALSE);
 
   /**
    * Checks if this result has type "int", with known or unknown value.
    */
-  bool get isAnyInt => identical(this, RESULT_INT) || _value is int;
+  bool get isAnyInt => identical(this, RESULT_INT) || value is int;
 
   /**
    * Checks if this result has one of the types - "bool", "num" or "string"; or may be `null`.
    */
-  bool get isAnyNullBoolNumString => isNull || isAnyBool || isAnyNum || _value is String;
+  bool get isAnyNullBoolNumString => isNull || isAnyBool || isAnyNum || value is String;
 
   /**
    * Checks if this result has type "num", with known or unknown value.
    */
-  bool get isAnyNum => isSomeNum || _value is num;
+  bool get isAnyNum => isSomeNum || value is num;
 
   /**
    * Checks if this result has type "bool", exact value of which we don't know.
    */
   bool get isSomeBool => identical(this, RESULT_BOOL);
 
   /**
    * Checks if this result has type "int", exact value of which we don't know.
    */
   bool get isSomeInt => identical(this, RESULT_INT);
@@ skipping 38 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);
 }