Generate unique names less aggressively.

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 128 matching lines @@
    */
   ConstantFinder() : super() {
   }
   /**
    * 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 initializer4 = node.initializer;
-    if (initializer4 != null && node.isConst()) {
-      VariableElement element23 = node.element;
-      if (element23 != null) {
-        _variableMap[element23] = node;
+    Expression initializer2 = node.initializer;
+    if (initializer2 != null && node.isConst()) {
+      VariableElement element2 = node.element;
+      if (element2 != null) {
+        _variableMap[element2] = 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 62 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 node3 = data.node;
-        Source source10 = variable.getAncestor(CompilationUnitElement).source;
-        errors.add(new AnalysisError.con2(source10, node3.offset, node3.length, data.errorCode, []));
+        ASTNode node2 = data.node;
+        Source source2 = variable.getAncestor(CompilationUnitElement).source;
+        errors.add(new AnalysisError.con2(source2, node2.offset, node2.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 121 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 element24 = node.methodName.element;
-    if (element24 is FunctionElement) {
-      FunctionElement function = element24 as FunctionElement;
+    Element element2 = node.methodName.element;
+    if (element2 is FunctionElement) {
+      FunctionElement function = element2 as FunctionElement;
       if (function.name == "identical") {
-        NodeList<Expression> arguments3 = node.argumentList.arguments;
-        if (arguments3.length == 2) {
+        NodeList<Expression> arguments2 = node.argumentList.arguments;
+        if (arguments2.length == 2) {
           Element enclosingElement2 = function.enclosingElement;
           if (enclosingElement2 is CompilationUnitElement) {
-            LibraryElement library30 = ((enclosingElement2 as CompilationUnitElement)).library;
-            if (library30.isDartCore()) {
-              EvaluationResultImpl leftArgument = arguments3[0].accept(this);
-              EvaluationResultImpl rightArgument = arguments3[1].accept(this);
+            LibraryElement library2 = ((enclosingElement2 as CompilationUnitElement)).library;
+            if (library2.isDartCore()) {
+              EvaluationResultImpl leftArgument = arguments2[0].accept(this);
+              EvaluationResultImpl rightArgument = arguments2[1].accept(this);
               return leftArgument.equalEqual(node, rightArgument);
             }
           }
         }
       }
     }
     return error(node, null);
   }
   EvaluationResultImpl visitNode(ASTNode node) => error(node, null);
   EvaluationResultImpl visitNullLiteral(NullLiteral node) => new ValidResult(null);
   EvaluationResultImpl visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
   EvaluationResultImpl visitPrefixedIdentifier(PrefixedIdentifier node) => getConstantValue(node, node.element);
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
-    EvaluationResultImpl operand3 = node.operand.accept(this);
+    EvaluationResultImpl operand2 = node.operand.accept(this);
     while (true) {
       if (node.operator.type == TokenType.BANG) {
-        return operand3.logicalNot(node);
+        return operand2.logicalNot(node);
       } else if (node.operator.type == TokenType.TILDE) {
-        return operand3.bitNot(node);
+        return operand2.bitNot(node);
       } else if (node.operator.type == TokenType.MINUS) {
-        return operand3.negated(node);
+        return operand2.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 412 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 element25 = node.element;
-    if (element25 is PropertyAccessorElement) {
-      element25 = ((element25 as PropertyAccessorElement)).variable;
+    Element element2 = node.element;
+    if (element2 is PropertyAccessorElement) {
+      element2 = ((element2 as PropertyAccessorElement)).variable;
     }
-    if (element25 is VariableElement) {
-      VariableElement variable = element25 as VariableElement;
+    if (element2 is VariableElement) {
+      VariableElement variable = element2 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 84 matching lines @@
   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 leftOperand3) {
-    Object leftValue = leftOperand3.value;
+  EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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));
       } 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)));
       }
     } else if (leftValue is 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 leftOperand4) {
-    Object leftValue = leftOperand4.value;
+  EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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 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 leftOperand5) {
-    Object leftValue = leftOperand5.value;
+  EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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 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 leftOperand6) {
-    Object leftValue = leftOperand6.value;
+  EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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 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 error(node);
   }
   EvaluationResultImpl divideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand7) {
-    Object leftValue = leftOperand7.value;
+  EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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());
         }
         return valueOf(((leftValue as int)) ~/ (_value as int));
@@ skipping 36 matching lines @@
     } else if (leftValue is String) {
       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 leftOperand8) {
-    Object leftValue = leftOperand8.value;
+  EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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);
       } 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)));
       }
     }
     return error(node);
   }
-  EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand9) {
-    Object leftValue = leftOperand9.value;
+  EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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);
       } 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)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl integerDivideError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand10) {
-    Object leftValue = leftOperand10.value;
+  EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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());
         }
         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 as int));
       }
     } else if (leftValue is double) {
       if (_value is int) {
         double result = ((leftValue as double)) / ((_value as int)).toDouble();
         return valueOf((result as int));
       } else if (_value is double) {
         double result = ((leftValue as double)) / ((_value as double));
         return valueOf((result as int));
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand11) {
-    Object leftValue = leftOperand11.value;
+  EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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);
       } 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)));
       }
     }
     return error(node);
   }
-  EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand12) {
-    Object leftValue = leftOperand12.value;
+  EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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);
       } else if (_value is double) {
         return valueOf2(((leftValue as int)).toDouble() < ((_value as double)));
       }
@@ skipping 16 matching lines @@
   }
   EvaluationResultImpl logicalOrError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl logicalOrValid(BinaryExpression node, ValidResult leftOperand) {
     Object leftValue = leftOperand.value;
     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 leftOperand13) {
-    Object leftValue = leftOperand13.value;
+  EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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));
       } else if (_value is double) {
         return valueOf3(((leftValue as int)).toDouble() - ((_value as double)));
       }
@@ skipping 32 matching lines @@
       return RESULT_TRUE;
     } else if (leftValue is String) {
       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 leftOperand14) {
-    Object leftValue = leftOperand14.value;
+  EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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());
         }
         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)));
       }
     }
     return error(node);
   }
   EvaluationResultImpl shiftLeftError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand15) {
-    Object leftValue = leftOperand15.value;
+  EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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 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 leftOperand16) {
-    Object leftValue = leftOperand16.value;
+  EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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 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 leftOperand17) {
-    Object leftValue = leftOperand17.value;
+  EvaluationResultImpl timesValid(BinaryExpression node, ValidResult leftOperand2) {
+    Object leftValue = leftOperand2.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));
       } else if (_value is double) {
         return valueOf3(((leftValue as int)).toDouble() * ((_value as double)));
       }
@@ skipping 54 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);
 }