Replace and remove JavaException(s).

pkg/analyzer/lib/src/dart/constant/value.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * The implementation of the class [DartObject].
  */
 library analyzer.src.dart.constant.value;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/error.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/utilities_general.dart';
 
 /**
  * The state of an object representing a boolean value.
  */
 class BoolState extends InstanceState {
   /**
    * An instance representing the boolean value 'false'.
    */
@@ skipping 206 matching lines @@
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     } else if (result is StringState) {
       return new DartObjectImpl(typeProvider.stringType, result);
     }
     // We should never get here.
-    throw new IllegalStateException("add returned a ${result.runtimeType}");
+    throw new StateError("add returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '&' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
@@ skipping 78 matching lines @@
       TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.divide(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
-    throw new IllegalStateException("divide returned a ${result.runtimeType}");
+    throw new StateError("divide returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '==' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
@@ skipping 148 matching lines @@
   DartObjectImpl minus(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.minus(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
-    throw new IllegalStateException("minus returned a ${result.runtimeType}");
+    throw new StateError("minus returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '-' operator on this object. The
    * [typeProvider] is the type provider used to find known types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
   DartObjectImpl negated(TypeProvider typeProvider) {
     InstanceState result = _state.negated();
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
-    throw new IllegalStateException("negated returned a ${result.runtimeType}");
+    throw new StateError("negated returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '!=' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
@@ skipping 40 matching lines @@
       TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.remainder(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
-    throw new IllegalStateException(
-        "remainder returned a ${result.runtimeType}");
+    throw new StateError("remainder returned a ${result.runtimeType}");
   }
 
   /**
    * Return the result of invoking the '<<' operator on this object with
    * the [rightOperand]. The [typeProvider] is the type provider used to find
    * known types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
@@ skipping 36 matching lines @@
   DartObjectImpl times(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.times(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
     // We should never get here.
-    throw new IllegalStateException("times returned a ${result.runtimeType}");
+    throw new StateError("times returned a ${result.runtimeType}");
   }
 
   @override
   bool toBoolValue() {
     InstanceState state = _state;
     if (state is BoolState) {
       return state.value;
     }
     return null;
   }
@@ skipping 563 matching lines @@
     if (rightOperand is IntState) {
       return IntState.UNKNOWN_VALUE;
     } else if (rightOperand is DoubleState) {
       return DoubleState.UNKNOWN_VALUE;
     }
     return NumState.UNKNOWN_VALUE;
   }
 }
 
 /**
- * A run-time exception that would be thrown during the evaluation of Dart code.
+ * Exception that would be thrown during the evaluation of Dart code.
  */
-class EvaluationException extends JavaException {
+class EvaluationException {

[Brian Wilkerson, 2016/09/08 22:38:57]

Should we do make this a subclass of AnalysisException? (I don't have the
context to know whether this class is used by any non-deprecated code.)

[scheglov, 2016/09/08 22:48:12]

EvaluationException does not have a message or cause.
So, probably it should not be AnalysisException.

   /**
    * The error code associated with the exception.
    */
   final ErrorCode errorCode;
 
   /**
    * Initialize a newly created exception to have the given [errorCode].
    */
   EvaluationException(this.errorCode);
 }
@@ skipping 1565 matching lines @@
       return BoolState.from(_type == rightType);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _type?.toString() ?? "-unknown-";
 }