Remove deprecated exception classes.

sdk/lib/core/errors.dart

 // Copyright (c) 2012, 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.
 
 class Error {
   const Error();
 }
 
 /**
  * Error thrown by the runtime system when an assert statement fails.
@@ skipping 26 matching lines @@
     if (message != null) {
       return "Illegal argument(s): $message";
     }
     return "Illegal argument(s)";
   }
 }
 
 /**
  * Exception thrown because of an index outside of the valid range.
  *
- * Temporarily implements [IndexOutOfRangeException] for backwards compatiblity.
  */
-class RangeError extends ArgumentError implements IndexOutOfRangeException {
+class RangeError extends ArgumentError {
   // TODO(lrn): This constructor should be called only with string values.
   // It currently isn't in all cases.
   /**
    * Create a new [RangeError] with the given [message].
    *
    * Temporarily made const for backwards compatibilty.
    */
-  const RangeError(var message) : super(message);
+  RangeError(var message) : super(message);
 
   /** Create a new [RangeError] with a message for the given [value]. */
   RangeError.value(num value) : super("value $value");
 
   String toString() => "RangeError: $message";
 }
 
-/**
- * Temporary backwards compatibilty class.
- *
- * This class allows code throwing the old [IndexOutOfRangeException] to
- * work until they change to the new [RangeError] name.
- * Constructor of [RangeError] is const only to support this interface.
- */
-interface IndexOutOfRangeException extends Exception default RangeError {
-  const IndexOutOfRangeException(var message);
-}
-
 
 /**
- * Temporary backwards compatibility class.
- *
- * Removed when users have had time to change to using [ArgumentError].
- */
-class IllegalArgumentException extends ArgumentError {
-  const IllegalArgumentException([argument = ""]) : super(argument);
-}
-
-/**
  * Error thrown when control reaches the end of a switch case.
  *
  * The Dart specification requires this error to be thrown when
  * control reaches the end of a switch case (except the last case
  * of a switch) without meeting a break or similar end of the control
  * flow.
  */
 class FallThroughError implements Error {
   const FallThroughError();
 }
 
+
 class AbstractClassInstantiationError implements Error {
   final String _className;
   const AbstractClassInstantiationError(String this._className);
   String toString() => "Cannot instantiate abstract class: '$_className'";
 }
 
 /**
  * Error thrown by the default implementation of [:noSuchMethod:] on [Object].
  */
 class NoSuchMethodError implements Error {
@@ skipping 104 matching lines @@
 
 /**
  * Thrown by operations that have not been implemented yet.
  *
  * This [Error] is thrown by unfinished code that hasn't yet implemented
  * all the features it needs.
  *
  * If a class is not intending to implement the feature, it should throw
  * an [UnsupportedError] instead. This error is only intended for
  * use during development.
- *
- * This class temporarily implements [Exception] for backwards compatibility.
- * The constructor is temporarily const to support [NotImplementedException].
  */
-class UnimplementedError implements UnsupportedError, NotImplementedException {
+class UnimplementedError implements UnsupportedError {
   final String message;
-  const UnimplementedError([String this.message]);
+  UnimplementedError([String this.message]);
   String toString() => (this.message != null
                         ? "UnimplementedError: $message"
                         : "UnimplementedError");
 }
 
 
-/** Temporary class added for backwards compatibility. Will be removed. */
-interface NotImplementedException extends Exception default UnimplementedError {
-  const NotImplementedException([String message]);
-}
-
-
 /**
  * The operation was not allowed by the current state of the object.
  *
  * This is a generic error used for a variety of different erroneous
  * actions. The message should be descriptive.
  */
 class StateError implements Error {
   final String message;
   StateError(this.message);
   String toString() => "Bad state: $message";
 }
 
 
 class OutOfMemoryError implements Error {
   const OutOfMemoryError();
   String toString() => "Out of Memory";
 }
 
 class StackOverflowError implements Error {
   const StackOverflowError();
   String toString() => "Stack Overflow";
 }