Improve java2dart code style - relax 'don't reference variable name in its initializer'.

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 42 matching lines @@
   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);
     }
     List<AnalysisError> errors = new List<AnalysisError>();
     for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
-      ASTNode node2 = data.node;
-      errors.add(new AnalysisError.con2(_source, node2.offset, node2.length, data.errorCode, []));
+      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 {@code EvaluationResult} represent the result of attempting to evaluate an
  * expression.
  */
 class EvaluationResult {
 
@@ skipping 68 matching lines @@
    */
   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;
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
-    Expression initializer2 = node.initializer;
-    if (initializer2 != null && node.isConst()) {
-      VariableElement element2 = node.element;
-      if (element2 != null) {
-        _variableMap[element2] = 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 {@code 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 {@link #add(CompilationUnit)} and then for the method{@link #computeValues()} to invoked exactly once. Any use of an instance after invoking the
  * method {@link #computeValues()} will result in unpredictable behavior.
@@ skipping 63 matching lines @@
   void computeValueFor(VariableElement variable) {
     VariableDeclaration declaration = _declarationMap[variable];
     if (declaration == null) {
       return;
     }
     EvaluationResultImpl result = declaration.initializer.accept(new ConstantVisitor());
     ((variable as VariableElementImpl)).evaluationResult = result;
     if (result is ErrorResult) {
       List<AnalysisError> errors = new List<AnalysisError>();
       for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
-        ASTNode node2 = data.node;
-        Source source2 = variable.getAncestor(CompilationUnitElement).source;
-        errors.add(new AnalysisError.con2(source2, node2.offset, node2.length, data.errorCode, []));
+        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
@@ skipping 129 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 element2 = node.methodName.element;
-    if (element2 is FunctionElement) {
-      FunctionElement function = element2 as FunctionElement;
+    Element element = node.methodName.element;
+    if (element is FunctionElement) {
+      FunctionElement function = element as FunctionElement;
       if (function.name == "identical") {
-        NodeList<Expression> arguments2 = node.argumentList.arguments;
-        if (arguments2.length == 2) {
-          Element enclosingElement2 = function.enclosingElement;
-          if (enclosingElement2 is CompilationUnitElement) {
-            LibraryElement library2 = ((enclosingElement2 as CompilationUnitElement)).library;
-            if (library2.isDartCore()) {
-              EvaluationResultImpl leftArgument = arguments2[0].accept(this);
-              EvaluationResultImpl rightArgument = arguments2[1].accept(this);
+        NodeList<Expression> arguments = node.argumentList.arguments;
+        if (arguments.length == 2) {
+          Element enclosingElement = function.enclosingElement;
+          if (enclosingElement is CompilationUnitElement) {
+            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 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) => getConstantValue(node, node.element);
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
-    EvaluationResultImpl operand2 = node.operand.accept(this);
-    if (operand2 is ValidResult && ((operand2 as ValidResult)).isNull()) {
+    EvaluationResultImpl operand = node.operand.accept(this);
+    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 operand2.logicalNot(node);
+        return operand.logicalNot(node);
       } else if (node.operator.type == TokenType.TILDE) {
-        return operand2.bitNot(node);
+        return operand.bitNot(node);
       } else if (node.operator.type == TokenType.MINUS) {
-        return operand2.negated(node);
+        return operand.negated(node);
       }
       break;
     }
     return error(node, null);
   }
   EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => getConstantValue(node, node.propertyName.element);
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(node, node.element);
   EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => new ValidResult(node.value);
   EvaluationResultImpl visitStringInterpolation(StringInterpolation node) {
     EvaluationResultImpl result = null;
@@ skipping 433 matching lines @@
    * 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 element2 = node.element;
-    if (element2 is PropertyAccessorElement) {
-      element2 = ((element2 as PropertyAccessorElement)).variable;
+    Element element = node.element;
+    if (element is PropertyAccessorElement) {
+      element = ((element as PropertyAccessorElement)).variable;
     }
-    if (element2 is VariableElement) {
-      VariableElement variable = element2 as VariableElement;
+    if (element is VariableElement) {
+      VariableElement variable = element as VariableElement;
       if (variable.isConst()) {
         _referenceGraph.addEdge(_source, variable);
       }
     }
     return null;
   }
 }
 /**
  * Instances of the class {@code ValidResult} represent the result of attempting to evaluate a valid
  * compile time constant expression.
@@ skipping 759 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);
 }