Fix names with '$' to not conflict with operators or internal helpers

frog/corejs.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.
 
 /**
  * Generates JS helpers for dart:core. This used to be in a file "core.js".
  * Having them in Dart code means we can easily control which are generated.
  */
 // TODO(jmesserly): one idea to make this cleaner: put these as private "native"
 // methods somewhere in a library that we import. This would be rather elegant
@@ skipping 32 matching lines @@
   /**
    * Generates the special operator method, e.g. $add.
    * We want to do $add(x, y) instead of x.$add(y) so it doesn't box.
    * Same idea for the other methods.
    */
   void useOperator(String name) {
     if (_usedOperators[name] != null) return;
 
     var code;
     switch (name) {
-      case '\$ne':
+      case ':ne':
         code = @"""
 function $ne(x, y) {
   if (x == null) return y != null;
   return (typeof(x) == 'number' && typeof(y) == 'number') ||
          (typeof(x) == 'boolean' && typeof(y) == 'boolean') ||
          (typeof(x) == 'string' && typeof(y) == 'string')
     ? x != y : !x.$eq(y);
 }""";
         break;
 
-      case '\$eq':
+      case ':eq':
         code = @"""
 function $eq(x, y) {
   if (x == null) return y == null;
   return (typeof(x) == 'number' && typeof(y) == 'number') ||
          (typeof(x) == 'boolean' && typeof(y) == 'boolean') ||
          (typeof(x) == 'string' && typeof(y) == 'string')
     ? x == y : x.$eq(y);
 }
 // TODO(jimhug): Should this or should it not match equals?
 Object.prototype.$eq = function(other) { return this === other; }""";
         break;
 
-      case '\$bit_not':
+      case ':bit_not':
         code = @"""
 function $bit_not(x) {
   return (typeof(x) == 'number') ? ~x : x.$bit_not();
 }""";
         break;
 
-      case '\$negate':
+      case ':negate':
         code = @"""
 function $negate(x) {
   return (typeof(x) == 'number') ? -x : x.$negate();
 }""";
         break;
 
       // This relies on JS's string "+" to match Dart's.
-      case '\$add':
+      case ':add':
         code = @"""
 function $add(x, y) {
   return ((typeof(x) == 'number' && typeof(y) == 'number') ||
           (typeof(x) == 'string'))
     ? x + y : x.$add(y);
 }""";
         break;
 
-      case '\$truncdiv':
+      case ':truncdiv':
         useThrow = true;
         code = @"""
 function $truncdiv(x, y) {
   if (typeof(x) == 'number' && typeof(y) == 'number') {
     if (y == 0) $throw(new IntegerDivisionByZeroException());
     var tmp = x / y;
     return (tmp < 0) ? Math.ceil(tmp) : Math.floor(tmp);
   } else {
     return x.$truncdiv(y);
   }
 }""";
         break;
 
-      case '\$mod':
+      case ':mod':
         code = @"""
 function $mod(x, y) {
   if (typeof(x) == 'number' && typeof(y) == 'number') {
     var result = x % y;
     if (result == 0) {
       return 0;  // Make sure we don't return -0.0.
     } else if (result < 0) {
       if (y < 0) {
         return result - y;
       } else {
         return result + y;
       }
     }
     return result;
   } else {
     return x.$mod(y);
   }
 }""";
         break;
 
       default:
         // All of the other helpers are generated the same way
         var op = TokenKind.rawOperatorFromMethod(name);
+        var jsname = world.toJsIdentifier(name);
         code = """
-function ${name}(x, y) {
+function $jsname(x, y) {
   return (typeof(x) == 'number' && typeof(y) == 'number')
-    ? x ${op} y : x.${name}(y);
+    ? x $op y : x.$jsname(y);
 }""";
         break;
     }
 
     _usedOperators[name] = code;
   }
 
   // NOTE: some helpers can't be generated when we generate corelib,
   // because we don't discover that we need them until later.
   // Generate on-demand instead
@@ skipping 293 matching lines @@
         w.writeln(@"function $wrap_call$1(fn) { return fn; }");
       }
     }
 
     // Write operator helpers
     for (var opImpl in orderValuesByKeys(_usedOperators)) {
       w.writeln(opImpl);
     }
   }
 }