Fix this longstanding bug that luckily did not bite us yet: Use Class.prototype.foo$bailout.call(th…

sdk/lib/_internal/compiler/implementation/js_backend/namer.dart

 // Copyright (c) 2011, 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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer {
@@ skipping 12 matching lines @@
   /**
    * Map from top-level or static elements to their unique identifiers provided
    * by [getName].
    *
    * Invariant: Keys must be declaration elements.
    */
   final Map<Element, String> globals;
   final Map<String, int> usedGlobals;
   final Map<String, LibraryElement> shortPrivateNameOwners;
 
+  /// A cache of names used for bailout methods. We make sure two

[karlklose, 2012/11/16 09:31:17]

I think you should /**...*/ here.

[ngeoffray, 2012/11/16 10:37:56]

Done.

+  /// bailout methods cannot have the same name because if one is

[karlklose, 2012/11/16 09:31:17]

I find "because if one is defined in a class that is a subclass of the other, we
would resolve to the wrong bailout method at runtime." hard to understand. How
about "because if the two bailout functions are in a class and its subclass, we
would call the wrong method at runtime."

[ngeoffray, 2012/11/16 10:37:56]

Done.

+  /// defined in a class that is a subclass of the other, we would
+  /// resolve to the wrong bailout method at runtime. To make it
+  /// simple, we don't keep track of inheritance and always avoid
+  /// similar names.
+  final Set<String> usedBailoutNames;
+  final Map<Element, String> bailoutNames;
+
   final Map<Constant, String> constantNames;
 
   Namer(this.compiler)
       : globals = new Map<Element, String>(),
         usedGlobals = new Map<String, int>(),
         shortPrivateNameOwners = new Map<String, LibraryElement>(),
+        bailoutNames = new Map<Element, String>(),
+        usedBailoutNames = new Set<String>(),
         constantNames = new Map<Constant, String>();
 
   final String CURRENT_ISOLATE = r'$';
   final String ISOLATE = 'Isolate';
   final String ISOLATE_PROPERTIES = r"$isolateProperties";
   /** Some closures must contain their name. The name is stored in
     * [STATIC_CLOSURE_NAME_NAME]. */

[karlklose, 2012/11/16 09:31:17]

Not your change, but break before "*/".

[ngeoffray, 2012/11/16 10:37:56]

Done.

   final String STATIC_CLOSURE_NAME_NAME = r'$name';
   static const SourceString CLOSURE_INVOCATION_NAME =
       Compiler.CALL_OPERATOR_NAME;
 
   String constantName(Constant constant) {
     // In the current implementation it doesn't make sense to give names to
     // function constants since the function-implementation itself serves as
     // constant and can be accessed directly.
     assert(!constant.isFunction());
     String result = constantNames[constant];
@@ skipping 174 matching lines @@
     } else if (identical(element.kind, ElementKind.LIBRARY)) {
       name = LIBRARY_PREFIX;
     } else {
       name = element.name.slowToString();
     }
     // Prefix the name with '$' if it is reserved.
     return safeName(name);
   }
 
   String getBailoutName(Element element) {
-    return '${getName(element)}\$bailout';
+    String name = bailoutNames[element];
+    if (name != null) return name;
+    String candidate = '${getName(element)}\$bailout';
+    name = candidate;
+    int i = 0;
+    while (usedBailoutNames.contains(name)) name = '$candidate${i++}';

[karlklose, 2012/11/16 09:31:17]

Should we have a UniqueElementNameGenerator abstraction? ;-)

+    bailoutNames[element] = name;
+    usedBailoutNames.add(name);
+    return name;
   }
 
   /**
    * Returns a preferred JS-id for the given element. The returned id is
    * guaranteed to be a valid JS-id. Globals and static fields are furthermore
    * guaranteed to be unique.
    *
    * For accessing statics consider calling
    * [isolateAccess]/[isolateBailoutAccess] or [isolatePropertyAccess] instead.
    */
@@ skipping 75 matching lines @@
   }
 
   String safeName(String name) {
     if (jsReserved.contains(name) || name.startsWith('\$')) {
       name = "\$$name";
       assert(!jsReserved.contains(name));
     }
     return name;
   }
 }