Convert subclasses of Enum

pkg/analyzer/lib/error/error.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.error.error;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/listener.dart';
@@ skipping 874 matching lines @@
         _uniqueNameToCodeMap[errorCode.uniqueName] = errorCode;
       }
     }
     return _uniqueNameToCodeMap[uniqueName];
   }
 }
 
 /**
  * The properties that can be associated with an [AnalysisError].
  */
-class ErrorProperty<V> extends Enum<ErrorProperty> {
+class ErrorProperty<V> implements Comparable<ErrorProperty> {
   /**
    * A property whose value is a list of [FieldElement]s that are final, but
    * not initialized by a constructor.
    */
   static const ErrorProperty<List<FieldElement>> NOT_INITIALIZED_FIELDS =
       const ErrorProperty<List<FieldElement>>('NOT_INITIALIZED_FIELDS', 0);
 
   /**
    * A property whose value is the name of the library that is used by all
    * of the "part of" directives, so should be used in the "library" directive.
    * Is `null` if there is no a single name used by all of the parts.
    */
   static const ErrorProperty<String> PARTS_LIBRARY_NAME =
       const ErrorProperty<String>('PARTS_LIBRARY_NAME', 1);
 
   /**
    * A property whose value is a list of [ExecutableElement] that should
    * be but are not implemented by a concrete class.
    */
   static const ErrorProperty<List<ExecutableElement>> UNIMPLEMENTED_METHODS =
       const ErrorProperty<List<ExecutableElement>>('UNIMPLEMENTED_METHODS', 2);
 
   static const List<ErrorProperty> values = const [
     NOT_INITIALIZED_FIELDS,
     PARTS_LIBRARY_NAME,
     UNIMPLEMENTED_METHODS
   ];
 
-  const ErrorProperty(String name, int ordinal) : super(name, ordinal);
+  /**
+   * The name of this property.
+   */
+  final String name;
+
+  /**
+   * The ordinal value of the property.
+   */
+  final int ordinal;
+
+  const ErrorProperty(this.name, this.ordinal);
+
+  @override
+  int get hashCode => ordinal;
+
+  @override
+  int compareTo(ErrorProperty other) => ordinal - other.ordinal;
+
+  @override
+  String toString() => name;
 }
 
 /**
  * The severity of an [ErrorCode].
  */
-class ErrorSeverity extends Enum<ErrorSeverity> {
+class ErrorSeverity implements Comparable<ErrorSeverity> {
   /**
    * The severity representing a non-error. This is never used for any error
    * code, but is useful for clients.
    */
   static const ErrorSeverity NONE = const ErrorSeverity('NONE', 0, " ", "none");
 
   /**
    * The severity representing an informational level analysis issue.
    */
   static const ErrorSeverity INFO = const ErrorSeverity('INFO', 1, "I", "info");
 
   /**
    * The severity representing a warning. Warnings can become errors if the `-Werror` command
    * line flag is specified.
    */
   static const ErrorSeverity WARNING =
       const ErrorSeverity('WARNING', 2, "W", "warning");
 
   /**
    * The severity representing an error.
    */
   static const ErrorSeverity ERROR =
       const ErrorSeverity('ERROR', 3, "E", "error");
 
   static const List<ErrorSeverity> values = const [NONE, INFO, WARNING, ERROR];
 
   /**
+   * The name of this error code.
+   */
+  final String name;
+
+  /**
+   * The ordinal value of the error code.
+   */
+  final int ordinal;
+
+  /**
    * The name of the severity used when producing machine output.
    */
   final String machineCode;
 
   /**
    * The name of the severity used when producing readable output.
    */
   final String displayName;
 
   /**
    * Initialize a newly created severity with the given names.
-   *
-   * Parameters:
-   * 0: the name of the severity used when producing machine output
-   * 1: the name of the severity used when producing readable output
    */
   const ErrorSeverity(
-      String name, int ordinal, this.machineCode, this.displayName)
-      : super(name, ordinal);
+      this.name, this.ordinal, this.machineCode, this.displayName);
+
+  @override
+  int get hashCode => ordinal;
+
+  @override
+  int compareTo(ErrorSeverity other) => ordinal - other.ordinal;
 
   /**
    * Return the severity constant that represents the greatest severity.
    */
   ErrorSeverity max(ErrorSeverity severity) =>
       this.ordinal >= severity.ordinal ? this : severity;
+
+  @override
+  String toString() => name;
 }
 
 /**
  * The type of an [ErrorCode].
  */
-class ErrorType extends Enum<ErrorType> {
+class ErrorType implements Comparable<ErrorType> {
   /**
    * Task (todo) comments in user code.
    */
   static const ErrorType TODO = const ErrorType('TODO', 0, ErrorSeverity.INFO);
 
   /**
    * Extra analysis run over the code to follow best practices, which are not in
    * the Dart Language Specification.
    */
   static const ErrorType HINT = const ErrorType('HINT', 1, ErrorSeverity.INFO);
@@ skipping 46 matching lines @@
     HINT,
     COMPILE_TIME_ERROR,
     CHECKED_MODE_COMPILE_TIME_ERROR,
     STATIC_WARNING,
     STATIC_TYPE_WARNING,
     SYNTACTIC_ERROR,
     LINT
   ];
 
   /**
+   * The name of this error type.
+   */
+  final String name;
+
+  /**
+   * The ordinal value of the error type.
+   */
+  final int ordinal;
+
+  /**
    * The severity of this type of error.
    */
   final ErrorSeverity severity;
 
   /**
    * Initialize a newly created error type to have the given [name] and
    * [severity].
    */
-  const ErrorType(String name, int ordinal, this.severity)
-      : super(name, ordinal);
+  const ErrorType(this.name, this.ordinal, this.severity);
 
   String get displayName => name.toLowerCase().replaceAll('_', ' ');
+
+  @override
+  int get hashCode => ordinal;
+
+  @override
+  int compareTo(ErrorType other) => ordinal - other.ordinal;
+
+  @override
+  String toString() => name;
 }