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';
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
+
 /**
  * Instances of the class `ConstantEvaluator` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
@@ skipping 20 matching lines @@
  *
  * </blockquote> The values returned by instances of this class are therefore `null` and
  * instances of the classes `Boolean`, `BigInteger`, `Double`, `String`, and
  * `DartObject`.
  *
  * In addition, this class defines several values that can be returned to indicate various
  * conditions encountered during evaluation. These are documented with the static field that define
  * those values.
  */
 class ConstantEvaluator {
-
   /**
    * The source containing the expression(s) that will be evaluated.
    */
   Source _source;
 
   /**
    * Initialize a newly created evaluator to evaluate expressions in the given source.
    *
    * @param source the source containing the expression(s) that will be evaluated
    */
   ConstantEvaluator(Source source) {
     this._source = source;
   }
+
   EvaluationResult evaluate(Expression expression) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor());
     if (result is ValidResult) {
-      return EvaluationResult.forValue(((result as ValidResult)).value);
+      return EvaluationResult.forValue((result as ValidResult).value);
     }
     List<AnalysisError> errors = new List<AnalysisError>();
-    for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
+    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, []));
     }
     return EvaluationResult.forErrors(new List.from(errors));
   }
 }
+
 /**
  * Instances of the class `EvaluationResult` represent the result of attempting to evaluate an
  * expression.
  */
 class EvaluationResult {
-
   /**
    * Return an evaluation result representing the result of evaluating an expression that is not a
    * compile-time constant because of the given errors.
    *
    * @param errors the errors that should be reported for the expression(s) that were evaluated
    * @return the result of evaluating an expression that is not a compile-time constant
    */
   static EvaluationResult forErrors(List<AnalysisError> errors) => new EvaluationResult(null, errors);
 
   /**
@@ skipping 36 matching lines @@
   List<AnalysisError> get errors => _errors == null ? AnalysisError.NO_ERRORS : _errors;
 
   /**
    * 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.
    */
   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;
       }
     }
     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
  * method [computeValues] will result in unpredictable behavior.
  */
 class ConstantValueComputer {
-
   /**
    * 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>();
@@ skipping 48 matching lines @@
    * Compute a value for the given variable.
    *
    * @param variable the variable for which a value is to be computed
    */
   void computeValueFor(VariableElement variable) {
     VariableDeclaration declaration = _declarationMap[variable];
     if (declaration == null) {
       return;
     }
     EvaluationResultImpl result = declaration.initializer.accept(new ConstantVisitor());
-    ((variable as VariableElementImpl)).evaluationResult = result;
+    (variable as VariableElementImpl).evaluationResult = result;
     if (result is ErrorResult) {
       List<AnalysisError> errors = new List<AnalysisError>();
-      for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
+      for (ErrorResult_ErrorData data in (result as ErrorResult).errorData) {
         ASTNode node = data.node;
         Source source = variable.getAncestor(CompilationUnitElement).source;
         errors.add(new AnalysisError.con2(source, node.offset, node.length, data.errorCode, []));
       }
     }
   }
 
   /**
    * Generate an error indicating that the given variable is not a valid compile-time constant
    * because it references at least one of the variables in the given cycle, each of which directly
    * or indirectly references the variable.
    *
    * @param variablesInCycle the variables in the cycle that includes the given variable
    * @param variable the variable that is not a valid compile-time constant
    */
   void generateCycleError(List<VariableElement> variablesInCycle, VariableElement variable) {
   }
 }
+
 /**
  * Instances of the class `ConstantVisitor` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  *
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to `null`.
  * * `null`.
@@ skipping 25 matching lines @@
     EvaluationResultImpl result = null;
     for (StringLiteral string in node.strings) {
       if (result == null) {
         result = string.accept(this);
       } else {
         result = result.concatenate(node, string.accept(this));
       }
     }
     return result;
   }
+
   EvaluationResultImpl visitBinaryExpression(BinaryExpression node) {
     EvaluationResultImpl leftResult = node.leftOperand.accept(this);
     EvaluationResultImpl rightResult = node.rightOperand.accept(this);
     TokenType operatorType = node.operator.type;
     if (operatorType != TokenType.BANG_EQ && operatorType != TokenType.EQ_EQ) {
-      if (leftResult is ValidResult && ((leftResult as ValidResult)).isNull || rightResult is ValidResult && ((rightResult as ValidResult)).isNull) {
+      if (leftResult is ValidResult && (leftResult as ValidResult).isNull || rightResult is ValidResult && (rightResult as ValidResult).isNull) {
         return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
       }
     }
     while (true) {
       if (operatorType == TokenType.AMPERSAND) {
         return leftResult.bitAnd(node, rightResult);
       } else if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
         return leftResult.logicalAnd(node, rightResult);
       } else if (operatorType == TokenType.BANG_EQ) {
         return leftResult.notEqual(node, rightResult);
@@ skipping 27 matching lines @@
         return leftResult.times(node, rightResult);
       } else if (operatorType == TokenType.SLASH) {
         return leftResult.divide(node, rightResult);
       } else if (operatorType == TokenType.TILDE_SLASH) {
         return leftResult.integerDivide(node, rightResult);
       }
       break;
     }
     return error(node, null);
   }
+
   EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => node.value ? ValidResult.RESULT_TRUE : ValidResult.RESULT_FALSE;
+
   EvaluationResultImpl visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     EvaluationResultImpl conditionResult = condition.accept(this);
     conditionResult = conditionResult.applyBooleanConversion(condition);
     if (conditionResult is ErrorResult) {
       return conditionResult;
     }
     EvaluationResultImpl thenResult = node.thenExpression.accept(this);
     if (thenResult is ErrorResult) {
       return thenResult;
     }
     EvaluationResultImpl elseResult = node.elseExpression.accept(this);
     if (elseResult is ErrorResult) {
       return elseResult;
     }
     return (identical(conditionResult, ValidResult.RESULT_TRUE)) ? thenResult : elseResult;
   }
+
   EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => new ValidResult(node.value);
+
   EvaluationResultImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (!node.isConst) {
       return error(node, null);
     }
     ConstructorElement constructor = node.staticElement;
     if (constructor != null && constructor.isConst) {
       node.argumentList.accept(this);
       return ValidResult.RESULT_OBJECT;
     }
     return error(node, null);
   }
+
   EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => new ValidResult(node.value);
+
   EvaluationResultImpl visitInterpolationExpression(InterpolationExpression node) {
     EvaluationResultImpl result = node.expression.accept(this);
     return result.performToString(node);
   }
+
   EvaluationResultImpl visitInterpolationString(InterpolationString node) => new ValidResult(node.value);
+
   EvaluationResultImpl visitListLiteral(ListLiteral node) {
     if (node.constKeyword == null) {
       return new ErrorResult.con1(node, CompileTimeErrorCode.MISSING_CONST_IN_LIST_LITERAL);
     }
     ErrorResult result = null;
     for (Expression element in node.elements) {
       result = union(result, element.accept(this));
     }
     if (result != null) {
       return result;
     }
     return ValidResult.RESULT_OBJECT;
   }
+
   EvaluationResultImpl visitMapLiteral(MapLiteral node) {
     if (node.constKeyword == null) {
       return new ErrorResult.con1(node, CompileTimeErrorCode.MISSING_CONST_IN_MAP_LITERAL);
     }
     ErrorResult result = null;
     for (MapLiteralEntry entry in node.entries) {
       result = union(result, entry.key.accept(this));
       result = union(result, entry.value.accept(this));
     }
     if (result != null) {
       return result;
     }
     return ValidResult.RESULT_OBJECT;
   }
+
   EvaluationResultImpl visitMethodInvocation(MethodInvocation node) {
     Element element = node.methodName.staticElement;
     if (element is FunctionElement) {
       FunctionElement function = element as FunctionElement;
       if (function.name == "identical") {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 2) {
           Element enclosingElement = function.enclosingElement;
           if (enclosingElement is CompilationUnitElement) {
-            LibraryElement library = ((enclosingElement as CompilationUnitElement)).library;
+            LibraryElement library = (enclosingElement as CompilationUnitElement).library;
             if (library.isDartCore) {
               EvaluationResultImpl leftArgument = arguments[0].accept(this);
               EvaluationResultImpl rightArgument = arguments[1].accept(this);
               return leftArgument.equalEqual(node, rightArgument);
             }
           }
         }
       }
     }
     return error(node, null);
   }
+
   EvaluationResultImpl visitNamedExpression(NamedExpression node) => node.expression.accept(this);
+
   EvaluationResultImpl visitNode(ASTNode node) => error(node, null);
+
   EvaluationResultImpl visitNullLiteral(NullLiteral node) => ValidResult.RESULT_NULL;
+
   EvaluationResultImpl visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
+
   EvaluationResultImpl visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixNode = node.prefix;
     Element prefixElement = prefixNode.staticElement;
     if (prefixElement is! PrefixElement) {
       EvaluationResultImpl prefixResult = prefixNode.accept(this);
       if (prefixResult is! ValidResult) {
         return error(node, null);
       }
     }
     return getConstantValue(node, node.staticElement);
   }
+
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
     EvaluationResultImpl operand = node.operand.accept(this);
-    if (operand is ValidResult && ((operand as ValidResult)).isNull) {
+    if (operand is ValidResult && (operand as ValidResult).isNull) {
       return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         return operand.logicalNot(node);
       } else if (node.operator.type == TokenType.TILDE) {
         return operand.bitNot(node);
       } else if (node.operator.type == TokenType.MINUS) {
         return operand.negated(node);
       }
       break;
     }
     return error(node, null);
   }
+
   EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => getConstantValue(node, node.propertyName.staticElement);
+
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(node, node.staticElement);
+
   EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => new ValidResult(node.value);
+
   EvaluationResultImpl visitStringInterpolation(StringInterpolation node) {
     EvaluationResultImpl result = null;
     for (InterpolationElement element in node.elements) {
       if (result == null) {
         result = element.accept(this);
       } else {
         result = result.concatenate(node, element.accept(this));
       }
     }
     return result;
   }
+
   EvaluationResultImpl visitSymbolLiteral(SymbolLiteral node) => ValidResult.RESULT_SYMBOL;
 
   /**
    * Return a result object representing an error associated with the given node.
    *
    * @param node the AST node associated with the error
    * @param code the error code indicating the nature of the error
    * @return a result object representing an error associated with the given node
    */
   ErrorResult error(ASTNode node, ErrorCode code) => new ErrorResult.con1(node, code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code);
 
   /**
    * Return the constant value of the static constant represented by the given element.
    *
    * @param node the node to be used if an error needs to be reported
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   EvaluationResultImpl getConstantValue(ASTNode node, Element element) {
     if (element is PropertyAccessorElement) {
-      element = ((element as PropertyAccessorElement)).variable;
+      element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElementImpl) {
       VariableElementImpl variableElementImpl = element as VariableElementImpl;
       EvaluationResultImpl value = variableElementImpl.evaluationResult;
       if (variableElementImpl.isConst && value != null) {
         return value;
       }
     } else if (element is ExecutableElement) {
-      if (((element as ExecutableElement)).isStatic) {
+      if ((element as ExecutableElement).isStatic) {
         return new ValidResult(element);
       }
-    } else if (element is ClassElement) {
+    } else if (element is ClassElement || element is FunctionTypeAliasElement) {
       return ValidResult.RESULT_OBJECT;
     }
     return error(node, null);
   }
 
   /**
    * Return the union of the errors encoded in the given results.
    *
    * @param leftResult the first set of errors, or `null` if there was no previous collection
    *          of errors
    * @param rightResult the errors to be added to the collection, or a valid result if there are no
    *          errors to be added
    * @return the union of the errors encoded in the given results
    */
   ErrorResult union(ErrorResult leftResult, EvaluationResultImpl rightResult) {
     if (rightResult is ErrorResult) {
       if (leftResult != null) {
         return new ErrorResult.con2(leftResult, rightResult as ErrorResult);
       } else {
         return rightResult as ErrorResult;
       }
     }
     return leftResult;
   }
 }
+
 /**
  * Instances of the class `DirectedGraph` implement a directed graph in which the nodes are
  * arbitrary (client provided) objects and edges are represented implicitly. The graph will allow an
  * edge from any node to any other node, including itself, but will not represent multiple edges
  * between the same pair of nodes.
  *
  * @param N the type of the nodes in the graph
  */
 class DirectedGraph<N> {
-
   /**
    * The table encoding the edges in the graph. An edge is represented by an entry mapping the head
    * to a set of tails. Nodes that are not the head of any edge are represented by an entry mapping
    * the node to an empty set of tails.
    */
   Map<N, Set<N>> _edges = new Map<N, Set<N>>();
 
   /**
    * Add an edge from the given head node to the given tail node. Both nodes will be a part of the
    * graph after this method is invoked, whether or not they were before.
@@ skipping 128 matching lines @@
    *
    * @return a sink node
    */
   N findSink() {
     for (N key in _edges.keys) {
       if (_edges[key].isEmpty) return key;
     }
     return null;
   }
 }
+
 /**
  * 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>();
 
   /**
    * 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));
   }
 
   /**
    * 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);
   }
+
   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;
+
   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);
+
   EvaluationResultImpl negated(Expression node) => this;
+
   EvaluationResultImpl notEqual(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.notEqualError(node, this);
+
   EvaluationResultImpl performToString(ASTNode node) => this;
+
   EvaluationResultImpl remainder(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.remainderError(node, this);
+
   EvaluationResultImpl shiftLeft(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftLeftError(node, this);
+
   EvaluationResultImpl shiftRight(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.shiftRightError(node, this);
+
   EvaluationResultImpl times(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.timesError(node, this);
+
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl bitOrError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl bitXorError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl concatenateError(Expression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl concatenateValid(Expression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl equalEqualError(Expression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl equalEqualValid(Expression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl logicalAndError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl logicalAndValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl logicalOrValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl notEqualError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl notEqualValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => new ErrorResult.con2(this, leftOperand);
+
   EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand) => this;
+
   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;
 
   /**
    * The error code for the error to be generated.
    */
   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;
   }
 }
+
 /**
  * Instances of the class `InternalResult` represent the result of attempting to evaluate a
  * expression.
  */
 abstract class EvaluationResultImpl {
   EvaluationResultImpl add(BinaryExpression node, EvaluationResultImpl rightOperand);
 
   /**
    * 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);
+
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl bitNot(Expression node);
+
   EvaluationResultImpl bitOr(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl bitXor(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl concatenate(Expression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl divide(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl equalEqual(Expression node, EvaluationResultImpl rightOperand);
+
   bool equalValues(EvaluationResultImpl result);
+
   EvaluationResultImpl greaterThan(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl greaterThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl integerDivide(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl lessThan(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl lessThanOrEqual(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl logicalAnd(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl logicalNot(Expression node);
+
   EvaluationResultImpl logicalOr(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl minus(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl negated(Expression node);
+
   EvaluationResultImpl notEqual(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl performToString(ASTNode node);
+
   EvaluationResultImpl remainder(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl shiftLeft(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl shiftRight(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl times(BinaryExpression node, EvaluationResultImpl rightOperand);
+
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl bitOrError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl bitXorError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl concatenateError(Expression node, ErrorResult leftOperand);
+
   EvaluationResultImpl concatenateValid(Expression node, ValidResult leftOperand);
+
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl equalEqualError(Expression node, ErrorResult leftOperand);
+
   EvaluationResultImpl equalEqualValid(Expression node, ValidResult leftOperand);
+
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl logicalAndError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl logicalAndValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl logicalOrValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl notEqualError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl notEqualValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl shiftRightError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand);
+
   EvaluationResultImpl timesError(BinaryExpression node, ErrorResult leftOperand);
+
   EvaluationResultImpl timesValid(BinaryExpression node, ValidResult leftOperand);
 }
+
 /**
  * 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;
 
   /**
    * 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;
 
   /**
    * 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;
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement) {
-      element = ((element as PropertyAccessorElement)).variable;
+      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 {
-
   /**
    * A result object representing the value 'false'.
    */
   static ValidResult RESULT_FALSE = new ValidResult(false);
 
   /**
    * A result object representing the an object without specific type on which no further operations
    * can be performed.
    */
   static ValidResult RESULT_DYNAMIC = new ValidResult(null);
@@ skipping 50 matching lines @@
   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;
   }
+
   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);
+
   EvaluationResultImpl bitAnd(BinaryExpression node, EvaluationResultImpl rightOperand) => rightOperand.bitAndValid(node, this);
+
   EvaluationResultImpl bitNot(Expression node) {
     if (isSomeInt) {
       return RESULT_INT;
     }
     if (value == null) {
       return error(node);
     } else if (value is int) {
-      return valueOf(~((value as 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);
+
   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) {
       return RESULT_TRUE;
     } else if (value is bool) {
-      return ((value as bool)) ? RESULT_FALSE : RESULT_TRUE;
+      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) {
       return error(node);
     } else if (value is int) {
-      return valueOf(-((value as int)));
+      return valueOf(-(value as int));
     } else if (value is double) {
-      return valueOf3(-((value as 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) {
       return valueOf4("null");
     } else if (value is bool) {
-      return valueOf4(((value as bool)).toString());
+      return valueOf4((value as bool).toString());
     } else if (value is int) {
-      return valueOf4(((value as int)).toString());
+      return valueOf4((value as int).toString());
     } else if (value is double) {
-      return valueOf4(((value as double)).toString());
+      return valueOf4((value as double).toString());
     } else if (value is String) {
       return this;
     } else if (isSomeBool) {
       return valueOf4("<some bool>");
     } else if (isSomeInt) {
       return valueOf4("<some int>");
     } else if (isSomeNum) {
       return valueOf4("<some num>");
     }
     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) {
       return "null";
     }
     return value.toString();
   }
+
   EvaluationResultImpl addToError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) + (value as int));
       } else if (value is double) {
-        return valueOf3(((leftValue as int)).toDouble() + ((value as 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());
+        return valueOf3((leftValue as double) + (value as int).toDouble());
       } else if (value is double) {
-        return valueOf3(((leftValue as double)) + ((value as 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))}");
+        return valueOf4("${(leftValue as String)}${(value as String)}");
       }
     }
     return error(node);
   }
+
   EvaluationResultImpl bitAndError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) & (value as int));
       }
       return error(node.leftOperand);
     }
     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 leftOperand) {
     if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) | (value as int));
       }
       return error(node.leftOperand);
     }
     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 leftOperand) {
     if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) ^ (value as int));
       }
       return error(node.leftOperand);
     }
     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))}");
+      return valueOf4("${(leftValue as String)}${(value as String)}");
     }
     return error(node);
   }
+
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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 as int) == 0) {
+          return valueOf3((leftValue as int).toDouble() / (value as int).toDouble());
         }
-        return valueOf(((leftValue as int)) ~/ (value as int));
+        return valueOf((leftValue as int) ~/ (value as int));
       } else if (value is double) {
-        return valueOf3(((leftValue as int)).toDouble() / ((value as 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());
+        return valueOf3((leftValue as double) / (value as int).toDouble());
       } else if (value is double) {
-        return valueOf3(((leftValue as double)) / ((value as 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);
-    } else if (leftValue is 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);
+        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));
+        return valueOf2((leftValue as double) == toDouble(value as int));
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) == value);
+        return valueOf2((leftValue as double) == value);
       }
       return RESULT_FALSE;
-    } else if (leftValue is String) {
-      if (value is String) {
-        return valueOf2(((leftValue as String)) == value);
-      }
-      return RESULT_FALSE;
+    } else {
+      return valueOf2(leftValue == value);
     }
-    return RESULT_FALSE;
   }
+
   EvaluationResultImpl greaterThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl greaterThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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);
+        return valueOf2((leftValue as int).compareTo(value as int) >= 0);
       } else if (value is double) {
-        return valueOf2(((leftValue as int)).toDouble() >= ((value as 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());
+        return valueOf2((leftValue as double) >= (value as int).toDouble());
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) >= ((value as double)));
+        return valueOf2((leftValue as double) >= (value as double));
       }
     }
     return error(node);
   }
+
   EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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);
+        return valueOf2((leftValue as int).compareTo(value as int) > 0);
       } else if (value is double) {
-        return valueOf2(((leftValue as int)).toDouble() > ((value as 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());
+        return valueOf2((leftValue as double) > (value as int).toDouble());
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) > ((value as double)));
+        return valueOf2((leftValue as double) > (value as double));
       }
     }
     return error(node);
   }
+
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (value is int) {
-        if (((value as int)) == 0) {
+        if ((value as int) == 0) {
           return error2(node, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE);
         }
-        return valueOf(((leftValue as int)) ~/ (value as int));
+        return valueOf((leftValue as int) ~/ (value as int));
       } else if (value is double) {
-        double result = ((leftValue as int)).toDouble() / ((value as 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();
+        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));
+        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 leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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);
+        return valueOf2((leftValue as int).compareTo(value as int) <= 0);
       } else if (value is double) {
-        return valueOf2(((leftValue as int)).toDouble() <= ((value as 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());
+        return valueOf2((leftValue as double) <= (value as int).toDouble());
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) <= ((value as double)));
+        return valueOf2((leftValue as double) <= (value as double));
       }
     }
     return error(node);
   }
+
   EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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);
+        return valueOf2((leftValue as int).compareTo(value as int) < 0);
       } else if (value is double) {
-        return valueOf2(((leftValue as int)).toDouble() < ((value as 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());
+        return valueOf2((leftValue as double) < (value as int).toDouble());
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) < ((value as 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 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))) {
+    if (leftValue is bool && (leftValue as bool)) {
       return RESULT_TRUE;
     }
     return booleanConversion(node.rightOperand, value);
   }
+
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) - (value as int));
       } else if (value is double) {
-        return valueOf3(((leftValue as int)).toDouble() - ((value as 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());
+        return valueOf3((leftValue as double) - (value as int).toDouble());
       } else if (value is double) {
-        return valueOf3(((leftValue as double)) - ((value as 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);
     } else if (leftValue is bool) {
       if (value is bool) {
-        return valueOf2(((leftValue as bool)) != ((value as 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);
+        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));
+        return valueOf2((leftValue as double) != toDouble(value as int));
       } else if (value is double) {
-        return valueOf2(((leftValue as double)) != value);
+        return valueOf2((leftValue as double) != value);
       }
       return RESULT_TRUE;
     } else if (leftValue is String) {
       if (value is String) {
-        return valueOf2(((leftValue as String)) != value);
+        return valueOf2((leftValue as String) != value);
       }
       return RESULT_TRUE;
     }
     return RESULT_TRUE;
   }
+
   EvaluationResultImpl remainderError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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 as int) == 0) {
+          return valueOf3((leftValue as int).toDouble() % (value as int).toDouble());
         }
-        return valueOf(((leftValue as int)).remainder(value as int));
+        return valueOf((leftValue as int).remainder(value as int));
       } else if (value is double) {
-        return valueOf3(((leftValue as int)).toDouble() % ((value as 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());
+        return valueOf3((leftValue as double) % (value as int).toDouble());
       } else if (value is double) {
-        return valueOf3(((leftValue as double)) % ((value as double)));
+        return valueOf3((leftValue as double) % (value as double));
       }
     }
     return error(node);
   }
+
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
+
   EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand) {
     if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } else if (value == null) {
       return error(node.rightOperand);
     } else if (leftValue is int) {
       if (value is int) {
         return RESULT_INT;
       }
       return error(node.rightOperand);
     }
     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 leftOperand) {
     if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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)));
+        return valueOf((leftValue as int) >> (value as int));
       }
       return error(node.rightOperand);
     }
     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 leftOperand) {
     if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
     if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
     Object leftValue = leftOperand.value;
     if (leftValue == null) {
       return error(node.leftOperand);
     } 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));
+        return valueOf((leftValue as int) * (value as int));
       } else if (value is double) {
-        return valueOf3(((leftValue as int)).toDouble() * ((value as 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());
+        return valueOf3((leftValue as double) * (value as int).toDouble());
       } else if (value is double) {
-        return valueOf3(((leftValue as double)) * ((value as 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
    * @param value the value to be converted to a boolean
    * @return the result of applying boolean conversion to the given value
    */
   EvaluationResultImpl booleanConversion(ASTNode node, Object value) {
     if (value is bool) {
       if (value as bool) {
         return RESULT_TRUE;
       } else {
         return RESULT_FALSE;
       }
     }
     return error(node);
   }
+
   ErrorResult error(ASTNode node) => error2(node, CompileTimeErrorCode.INVALID_CONSTANT);
 
   /**
    * Return a result object representing an error associated with the given node.
    *
    * @param node the AST node associated with the error
    * @param code the error code indicating the nature of the error
    * @return a result object representing an error associated with the given node
    */
   ErrorResult error2(ASTNode node, ErrorCode code) => new ErrorResult.con1(node, code);
@@ skipping 25 matching lines @@
 
   /**
    * Checks if this result has type "int", exact value of which we don't know.
    */
   bool get isSomeInt => identical(this, RESULT_INT);
 
   /**
    * Checks if this result has type "num" (or "int"), exact value of which we don't know.
    */
   bool get isSomeNum => identical(this, RESULT_DYNAMIC) || identical(this, RESULT_INT) || identical(this, RESULT_NUM);
+
   double toDouble(int value) => value.toDouble();
 
   /**
    * Return an error result that is the union of the two given error results.
    *
    * @param firstError the first error to be combined
    * @param secondError the second error to be combined
    * @return an error result that is the union of the two given error results
    */
   ErrorResult union(ErrorResult firstError, ErrorResult secondError) => new ErrorResult.con2(firstError, secondError);
@@ skipping 23 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);
 }