Replace and remove JavaException(s).

pkg/analyzer/lib/src/generated/java_core.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.
 
 library analyzer.src.generated.java_core;
 
 final Stopwatch nanoTimeStopwatch = new Stopwatch();
 
 /**
  * Inserts the given arguments into [pattern].
@@ skipping 68 matching lines @@
       if (c == 0x64) {
         sb.write(args[argIndex++]);
         continue;
       }
       // %s
       if (c == 0x73) {
         sb.write(args[argIndex++]);
         continue;
       }
       // unknown
-      throw new IllegalArgumentException(
-          '[$fmt][$i] = 0x${c.toRadixString(16)}');
+      throw new ArgumentError('[$fmt][$i] = 0x${c.toRadixString(16)}');
     } else {
       sb.writeCharCode(c);
     }
   }
   return sb.toString();
 }
 
 class Character {
   static const int MAX_VALUE = 0xffff;
   static const int MAX_CODE_POINT = 0x10ffff;
@@ skipping 22 matching lines @@
   static bool isLetter(int c) =>
       c >= 0x41 && c <= 0x5A || c >= 0x61 && c <= 0x7A;
 
   static bool isLetterOrDigit(int c) => isLetter(c) || isDigit(c);
 
   static bool isWhitespace(int c) =>
       c == 0x09 || c == 0x20 || c == 0x0A || c == 0x0D;
 
   static String toChars(int codePoint) {
     if (codePoint < 0 || codePoint > MAX_CODE_POINT) {
-      throw new IllegalArgumentException();
+      throw new ArgumentError();
     }
     if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) {
       return new String.fromCharCode(codePoint);
     }
     int offset = codePoint - MIN_SUPPLEMENTARY_CODE_POINT;
     int c0 = ((offset & 0x7FFFFFFF) >> 10) + MIN_HIGH_SURROGATE;
     int c1 = (offset & 0x3ff) + MIN_LOW_SURROGATE;
     return new String.fromCharCodes([c0, c1]);
   }
 }
 
 abstract class Enum<E extends Enum> implements Comparable<E> {
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
   const Enum(this.name, this.ordinal);
   int get hashCode => ordinal;
   int compareTo(E other) => ordinal - other.ordinal;
   String toString() => name;
 }
 
-class IllegalArgumentException extends JavaException {

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

Should we deprecate these instead of deleting them? (Otherwise this is
technically a breaking change. Not sure whether it matters in this case, though
it might have for StringUtils.)

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

Fortunately almost nobody uses these removed classes.
We had only couple of uses, all of them in the internal-only code.
So, I'm applying the same changes to the internal code.

-  IllegalArgumentException([message = "", cause = null])
-      : super(message, cause);
-}
-
-class IllegalStateException extends JavaException {
-  IllegalStateException([message = ""]) : super(message);
-}
-
 class JavaArrays {
   static int makeHashCode(List a) {
     // TODO(rnystrom): This is not used by analyzer, but is called by
     // analysis_server. Move this code there and remove it from here.
     if (a == null) {
       return 0;
     }
     int result = 1;
     for (var element in a) {
       result = 31 * result + (element == null ? 0 : element.hashCode);
     }
     return result;
   }
 }
 
-class JavaException implements Exception {
-  final String message;
-  final Object cause;
-  JavaException([this.message = "", this.cause = null]);
-  JavaException.withCause(this.cause) : message = null;
-  String toString() => "$runtimeType: $message $cause";
-}
-
-class JavaIOException extends JavaException {
-  JavaIOException([message = "", cause = null]) : super(message, cause);
-}
-
 class JavaPatternMatcher {
   Iterator<Match> _matches;
   Match _match;
   JavaPatternMatcher(RegExp re, String input) {
     _matches = re.allMatches(input).iterator;
   }
   int end() => _match.end;
   bool find() {
     if (!_matches.moveNext()) {
       return false;
@@ skipping 27 matching lines @@
   }
 
   static int nanoTime() {
     if (!nanoTimeStopwatch.isRunning) {
       nanoTimeStopwatch.start();
     }
     return nanoTimeStopwatch.elapsedMicroseconds * 1000;
   }
 }
 
-class MissingFormatArgumentException implements Exception {
-  final String s;
-
-  MissingFormatArgumentException(this.s);
-
-  String toString() => "MissingFormatArgumentException: $s";
-}
-
-class NoSuchElementException extends JavaException {
-  String toString() => "NoSuchElementException";
-}
-
-class NotImplementedException extends JavaException {
-  NotImplementedException(message) : super(message);
-}
-
-class NumberFormatException extends JavaException {
-  String toString() => "NumberFormatException";
-}
-
 class PrintStringWriter extends PrintWriter {
   final StringBuffer _sb = new StringBuffer();
 
   void print(x) {
     _sb.write(x);
   }
 
   String toString() => _sb.toString();
 }
 
 abstract class PrintWriter {
   void newLine() {
     this.print('\n');
   }
 
   void print(x);
 
   void printf(String fmt, List args) {
     this.print(_printf(fmt, args));
   }
 
   void println(String s) {
     this.print(s);
     this.newLine();
   }
 }
 
-class RuntimeException extends JavaException {
-  RuntimeException({String message: "", Exception cause: null})
-      : super(message, cause);
-}
-
-class StringIndexOutOfBoundsException extends JavaException {
-  StringIndexOutOfBoundsException(int index) : super('$index');
-}
-
-class UnsupportedOperationException extends JavaException {
-  UnsupportedOperationException([message = ""]) : super(message);
-}
-
 class URISyntaxException implements Exception {
   final String message;
   URISyntaxException(this.message);
   String toString() => "URISyntaxException: $message";
 }