Issue 13584. Fix for Java/Dart local variable scoping mismatch.

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 1085 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl addToValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
-    } else if (isSomeNum || leftOperand2.isSomeNum) {
+    } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
-    Object leftValue = leftOperand2.value;
+    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));
       } 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 leftOperand2) {
-    if (!isAnyInt || !leftOperand2.isAnyInt) {
+  EvaluationResultImpl bitAndValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 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 leftOperand2) {
-    if (!isAnyInt || !leftOperand2.isAnyInt) {
+  EvaluationResultImpl bitOrValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 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 leftOperand2) {
-    if (!isAnyInt || !leftOperand2.isAnyInt) {
+  EvaluationResultImpl bitXorValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl divideValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
-    Object leftValue = leftOperand2.value;
+    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());
         }
         return valueOf(((leftValue as int)) ~/ (value as int));
@@ skipping 41 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl greaterThanOrEqualValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
-    Object leftValue = leftOperand2.value;
+    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);
       } 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl greaterThanValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
-    Object leftValue = leftOperand2.value;
+    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);
       } 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl integerDivideValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 error2(node, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE);
         }
         return valueOf(((leftValue as int)) ~/ (value as int));
       } else if (value is double) {
         double result = ((leftValue as int)).toDouble() / ((value as double));
         return valueOf(result.toInt());
       }
     } else if (leftValue is double) {
       if (value is int) {
         double result = ((leftValue as double)) / ((value as int)).toDouble();
         return valueOf(result.toInt());
       } else if (value is double) {
         double result = ((leftValue as double)) / ((value as double));
         return valueOf(result.toInt());
       }
     }
     return error(node);
   }
   EvaluationResultImpl lessThanError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
   EvaluationResultImpl lessThanOrEqualError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl lessThanOrEqualValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
-    Object leftValue = leftOperand2.value;
+    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);
       } 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl lessThanValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeNum || leftOperand2.isSomeNum) {
+    if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_BOOL;
     }
-    Object leftValue = leftOperand2.value;
+    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);
       } else if (value is double) {
         return valueOf2(((leftValue as int)).toDouble() < ((value as double)));
       }
@@ skipping 31 matching lines @@
     if (isSomeBool || leftOperand.isSomeBool) {
       return RESULT_BOOL;
     }
     Object leftValue = leftOperand.value;
     if (leftValue is bool && ((leftValue as bool))) {
       return RESULT_TRUE;
     }
     return booleanConversion(node.rightOperand, value);
   }
   EvaluationResultImpl minusError(BinaryExpression node, ErrorResult leftOperand) => leftOperand;
-  EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl minusValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
-    } else if (isSomeNum || leftOperand2.isSomeNum) {
+    } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
-    Object leftValue = leftOperand2.value;
+    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));
       } else if (value is double) {
         return valueOf3(((leftValue as int)).toDouble() - ((value as double)));
       }
@@ skipping 35 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl remainderValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
-    } else if (isSomeNum || leftOperand2.isSomeNum) {
+    } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
-    Object leftValue = leftOperand2.value;
+    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());
         }
         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 leftOperand2) {
-    if (!isAnyInt || !leftOperand2.isAnyInt) {
+  EvaluationResultImpl shiftLeftValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 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 leftOperand2) {
-    if (!isAnyInt || !leftOperand2.isAnyInt) {
+  EvaluationResultImpl shiftRightValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyInt || !leftOperand.isAnyInt) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_INT);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
     }
-    Object leftValue = leftOperand2.value;
+    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 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 leftOperand2) {
-    if (!isAnyNum || !leftOperand2.isAnyNum) {
+  EvaluationResultImpl timesValid(BinaryExpression node, ValidResult leftOperand) {
+    if (!isAnyNum || !leftOperand.isAnyNum) {
       return error2(node, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM);
     }
-    if (isSomeInt || leftOperand2.isSomeInt) {
+    if (isSomeInt || leftOperand.isSomeInt) {
       return RESULT_INT;
-    } else if (isSomeNum || leftOperand2.isSomeNum) {
+    } else if (isSomeNum || leftOperand.isSomeNum) {
       return RESULT_NUM;
     }
-    Object leftValue = leftOperand2.value;
+    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));
       } else if (value is double) {
         return valueOf3(((leftValue as int)).toDouble() * ((value as double)));
       }
@@ skipping 106 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);
 }