Implement canonical name scheme in kernel.

pkg/kernel/lib/transformations/insert_covariance_checks.dart

 // Copyright (c) 2016, 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 kernel.transformations.insert_covariance_checks;
 
 import '../class_hierarchy.dart';
 import '../clone.dart';
 import '../core_types.dart';
 import '../kernel.dart';
 import '../log.dart';
 import '../type_algebra.dart';
 import '../type_environment.dart';
 
-// TODO: Should helper be removed?
 DartType substituteBounds(DartType type, Map<TypeParameter, DartType> upper,
     Map<TypeParameter, DartType> lower) {
   return Substitution
       .fromUpperAndLowerBounds(upper, lower)
       .substituteType(type);
 }
 
 /// Inserts checked entry points for methods in order to enforce type safety
 /// in face on covariant subtyping.
 ///
@@ skipping 85 matching lines @@
   //
   // The "substitution" maps translate type parameters to their exact type,
   // while the "upper bound" maps translate type parameters to their erased
   // upper bounds.
   Map<TypeParameter, DartType> ownSubstitution;
   Map<TypeParameter, DartType> ownUpperBounds;
   Map<TypeParameter, DartType> superSubstitution;
   Map<TypeParameter, DartType> superUpperBounds;
 
   /// Members for which a checked entry point must be created in this current
-  /// class.
-  Set<Member> membersNeedingCheckedEntryPoint = new Set<Member>();
+  /// class, indexed by name.
+  Map<Name, Member> membersNeedingCheckedEntryPoint = <Name, Member>{};
 
   _ClassTransformer(this.host, InsertCovarianceChecks global)
       : hierarchy = global.hierarchy,
         types = global.types,
         this.global = global;
 
   /// Mark [parameter] unsafe, with [type] as a potential argument type.
   void addUnsafeParameter(
       VariableDeclaration parameter, DartType type, Member member) {
     unsafeParameterTypes.putIfAbsent(parameter, () => <DartType>[]).add(type);
@@ skipping 19 matching lines @@
   bool hasCheckedEntryPoint(Member member, {bool setter: false}) {
     if (!setter && member is Field) {
       return false; // Field getters never have checked entry points.
     }
     return global.membersWithCheckedEntryPoint.contains(member);
   }
 
   /// Ensures that a checked entry point for [member] will be emitted in the
   /// current class.
   void requireLocalCheckedEntryPoint(Member member) {
-    if (membersNeedingCheckedEntryPoint.add(member)) {
-      global.membersWithCheckedEntryPoint.add(member);
-    }
+    membersNeedingCheckedEntryPoint[member.name] = member;
+    global.membersWithCheckedEntryPoint.add(member);
   }
 
   void transformClass() {
     if (host.isMixinApplication) {
       // TODO(asgerf): We need a way to support mixin applications with unsafe
       //   overrides. This version assumes mixins have been resolved by cloning.
       //   We could generate a subclass of the mixin application containing the
       //   checked entry points.
       throw 'Mixin applications must be resolved before inserting covariance '
           'checks';
@@ skipping 44 matching lines @@
         if (superMember is Procedure) {
           checkProcedureOverride(ownMember, superMember);
         } else if (superMember is Field && isSetter) {
           checkSetterFieldOverride(ownMember, superMember);
         }
       } else if (isSetter) {
         checkFieldOverride(ownMember, superMember);
       }
     });
 
-    for (Member member in membersNeedingCheckedEntryPoint) {
+    for (Member member in membersNeedingCheckedEntryPoint.values) {
       ownSubstitution = getSubstitutionMap(
           hierarchy.getClassAsInstanceOf(host, member.enclosingClass));
       ownSubstitution = ensureMutable(ownSubstitution);
       generateCheckedEntryPoint(member);
     }
   }
 
   /// Compute an upper bound of the types in [inputTypes].
   ///
   /// We use this to compute a trustworthy type for a parameter, given a list
@@ skipping 276 matching lines @@
   @override
   visitPropertySet(PropertySet node) {
     var target = getChecked(node.receiver, node.interfaceTarget);
     if (target != null) {
       node.interfaceTarget = target;
       node.name = target.name;
     }
     node.visitChildren(this);
   }
 }