Remove weird operator== implementations.

dart/sdk/lib/_internal/compiler/implementation/dart_types.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.
 
 library dart_types;
 
 import 'dart2jslib.dart' show Compiler, invariant, Script, Message;
 import 'elements/modelx.dart'
     show VoidElementX, LibraryElementX, BaseClassElementX;
 import 'elements/elements.dart';
@@ skipping 76 matching lines @@
   /**
    * Calls [f] with each [MalformedType] within this type.
    *
    * If [f] returns [: false :], the traversal stops prematurely.
    *
    * [forEachMalformedType] returns [: false :] if the traversal was stopped
    * prematurely.
    */
   bool forEachMalformedType(bool f(MalformedType type)) => true;
 
-  // TODO(ahe): This is implicitly inherited from Object.  What is the purpose
-  // of duplicating it here?
-  bool operator ==(other);
-
   /**
    * Is [: true :] if this type has no explict type arguments.
    */
   bool get isRaw => true;
 
   DartType asRaw() => this;
 
   /**
    * Is [: true :] if this type is the dynamic type.
    */
@@ skipping 228 matching lines @@
   bool get isMalformed => true;
 
   bool forEachMalformedType(bool f(MalformedType type)) => f(this);
 
   DartType unalias(Compiler compiler) => this;
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitMalformedType(this, argument);
   }
 
-  // TODO(ahe): This is the default implementation that would be inherited if
-  // DartType didn't declare an abstract method.  What is the purpose?
-  bool operator ==(other) => identical(this, other);
-
   String toString() {
     var sb = new StringBuffer();
     if (typeArguments != null) {
       if (userProvidedBadType != null) {
         sb.write(userProvidedBadType.name.slowToString());
       } else {
         sb.write(element.name.slowToString());
       }
       if (!typeArguments.isEmpty) {
         sb.write('<');
@@ skipping 86 matching lines @@
          !arguments.isEmpty;
          arguments = arguments.tail) {
       int argumentHash = arguments.head != null ? arguments.head.hashCode : 0;
       hash = 17 * hash + 3 * argumentHash;
     }
     return hash;
   }
 
   bool operator ==(other) {
     if (other is !GenericType) return false;
-    return identical(element, other.element)
+    return kind == other.kind
+        && element == other.element
         && typeArguments == other.typeArguments;
   }
 
   bool get isRaw => typeArguments.isEmpty || identical(this, element.rawType);
 
   GenericType asRaw() => element.rawType;
 }
 
-// TODO(johnniwinther): Add common supertype for InterfaceType and TypedefType.
 class InterfaceType extends GenericType {
   final ClassElement element;
 
   InterfaceType(this.element,
                 [Link<DartType> typeArguments = const Link<DartType>()])
       : super(typeArguments, hasMalformed(typeArguments)) {
     assert(invariant(element, element.isDeclaration));
     assert(invariant(element, element.thisType == null ||
         typeArguments.slowLength() == element.typeVariables.slowLength(),
         message: () => 'Invalid type argument count on ${element.thisType}. '
@@ skipping 67 matching lines @@
       declarer = supertype;
       ClassElement lookupTarget = declarer.element;
       member = lookupTarget.implementation.lookupLocalMember(name);
       if (member != null) {
         return createMember(receiver, declarer, member);
       }
     }
     return null;
   }
 
-  bool operator ==(other) {
-    // TODO(johnniwinther,karlklose): This is a bad implementation of
-    // operator==.  This implementation is not compatible with the
-    // implementation in the superclass: another subclass of GenericType might
-    // compare equal to an instance of this class if the other subclass forgets
-    // to implement operator==.  This is brittle and easy to avoid, ask ahe@
-    // for concrete suggestions.
-    if (other is !InterfaceType) return false;
-    return super == other;
-  }
-
   int get hashCode => super.hashCode;
 
   InterfaceType asRaw() => super.asRaw();
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitInterfaceType(this, argument);
   }
 }
 
 class FunctionType extends DartType {
@@ skipping 242 matching lines @@
   SourceString get name => element.name;
 
   DartType unalias(Compiler compiler) {
     // TODO(ahe): This should be [ensureResolved].
     compiler.resolveTypedef(element);
     DartType definition = element.alias.unalias(compiler);
     TypedefType declaration = element.computeType(compiler);
     return definition.subst(typeArguments, declaration.typeArguments);
   }
 
-  bool operator ==(other) {
-    // TODO(johnniwinther,karlklose): See InterfaceType.operator==.
-    if (other is !TypedefType) return false;
-    return super == other;
-  }
-
   int get hashCode => super.hashCode;
 
   TypedefType asRaw() => super.asRaw();
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitTypedefType(this, argument);
   }
 }
 
 /**
@@ skipping 418 matching lines @@
       : super(compiler, dynamicType, voidType);
 
 
   bool isSubtype(DartType t, DartType s) {
     if (t is TypeVariableType || s is TypeVariableType) {
       return true;
     }
     return super.isSubtype(t, s);
   }
 }