New Analysis Engine translation.

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';
@@ skipping 233 matching lines @@
     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 element21 = node.methodName.element;
-    if (element21 is FunctionElement) {
-      FunctionElement function = element21 as FunctionElement;
+    Element element23 = node.methodName.element;
+    if (element23 is FunctionElement) {
+      FunctionElement function = element23 as FunctionElement;
       if (function.name == "identical") {
         NodeList<Expression> arguments3 = node.argumentList.arguments;
         if (arguments3.length == 2) {
           Element enclosingElement2 = function.enclosingElement;
           if (enclosingElement2 is CompilationUnitElement) {
             LibraryElement library20 = ((enclosingElement2 as CompilationUnitElement)).library;
             if (library20.isDartCore()) {
               EvaluationResultImpl leftArgument = arguments3[0].accept(this);
               EvaluationResultImpl rightArgument = arguments3[1].accept(this);
               return leftArgument.equalEqual(node, rightArgument);
@@ skipping 89 matching lines @@
    * The errors that prevent the expression from being a valid compile time constant.
    */
   List<ErrorResult_ErrorData> _errors = new List<ErrorResult_ErrorData>();
   /**
    * Initialize a newly created result representing the error with the given code reported against
    * the given node.
    * @param node the node against which the error should be reported
    * @param errorCode the error code for the error to be generated
    */
   ErrorResult.con1(ASTNode node, ErrorCode errorCode) {
-    _jtd_constructor_158_impl(node, errorCode);
+    _jtd_constructor_157_impl(node, errorCode);
   }
-  _jtd_constructor_158_impl(ASTNode node, ErrorCode errorCode) {
+  _jtd_constructor_157_impl(ASTNode node, ErrorCode errorCode) {
     _errors.add(new ErrorResult_ErrorData(node, errorCode));
   }
   /**
    * Initialize a newly created result to represent the union of the errors in the given result
    * objects.
    * @param firstResult the first set of results being merged
    * @param secondResult the second set of results being merged
    */
   ErrorResult.con2(ErrorResult firstResult, ErrorResult secondResult) {
-    _jtd_constructor_159_impl(firstResult, secondResult);
+    _jtd_constructor_158_impl(firstResult, secondResult);
   }
-  _jtd_constructor_159_impl(ErrorResult firstResult, ErrorResult secondResult) {
+  _jtd_constructor_158_impl(ErrorResult firstResult, ErrorResult secondResult) {
     _errors.addAll(firstResult._errors);
     _errors.addAll(secondResult._errors);
   }
   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);
@@ skipping 715 matching lines @@
    * @return a result object representing the given value
    */
   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);
 }