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

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 476 matching lines @@
     if (y.span == null) return -1;
 
     // If that fails, compare by name.
     return x.name.compareTo(y.name);
   }
 
   /** Marks that a map literal is used, e.g. a call to $map. */
   Type useMapFactory() {
     corejs.useMap = true;
     var factType = world.coreimpl.types['HashMapImplementation'];
-    var m = factType.resolveMember('\$setindex');
+    var m = factType.resolveMember(':setindex');
     genMethod(m.members[0]); // TODO(jimhug): Clean up initializing.
     var c = factType.getConstructor('');
     genMethod(c);
     return factType;
   }
 }
 
 
 class BlockScope {
   MethodGenerator enclosingMethod;
@@ skipping 77 matching lines @@
     if (isMethodScope && _closedOver.contains(name)) return true;
 
     for (var s = parent; s != null; s = s.parent) {
       if (s._vars.containsKey(name)) return true;
       if (s._jsNames.contains(name)) return true;
       // Don't reuse a name that's been closed over
       if (s.isMethodScope && s._closedOver.contains(name)) return true;
     }
 
     // Ensure that we don't shadow another name that would've been accessible,
-    // like to level names.
+    // like top level names.
     // (This lookup might report errors, which is a bit strange.
     // But probably harmless since we have to pay for the lookup anyway.)
+    // TODO(jmesserly): does this work right if JS name of the top-level thing
+    // is different from Dart name?
     final type = enclosingMethod.method.declaringType;
     if (type.library.lookup(name, null) != null) return true;
 
     // Nobody else needs this name. It's safe to reuse.
     return false;
   }
 
 
   Value create(String name, Type type, SourceSpan span,
       [bool isFinal = false, bool isParameter = false]) {
@@ skipping 797 matching lines @@
     if (list.needsTemp) {
       listVar = _scope.create('\$list', list.type, null);
       writer.writeln('var ${listVar.code} = ${list.code};');
     }
 
     // Special path for list for readability and perf optimization.
     if (list.type.isList) {
       var tmpi = _scope.create('\$i', world.numType, null);
       writer.enterBlock('for (var ${tmpi.code} = 0;' +
           '${tmpi.code} < ${listVar.code}.length; ${tmpi.code}++) {');
-      var value = listVar.invoke(this, '\$index', node.list,
+      var value = listVar.invoke(this, ':index', node.list,
           new Arguments(null, [tmpi]));
       writer.writeln('var ${item.code} = ${value.code};');
     } else {
       _pushBlock();
       var iterator = list.invoke(this, 'iterator', node.list, Arguments.EMPTY);
       var tmpi = _scope.create('\$i', iterator.type, null);
 
       var hasNext = tmpi.invoke(this, 'hasNext', node.list, Arguments.EMPTY);
       var next = tmpi.invoke(this, 'next', node.list, Arguments.EMPTY);
 
@@ skipping 275 matching lines @@
 
     var w = new CodeWriter();
     meth.generator.writeDefinition(w, node);
 
     return new Value(meth.functionType, w.text, node.span);
   }
 
   visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
-    var name = '\$call';
+    var name = ':call';
     if (node.target is DotExpression) {
       DotExpression dot = node.target;
       target = dot.self.visit(this);
       name = dot.name.name;
       position = dot.name;
     } else if (node.target is VarExpression) {
       VarExpression varExpr = node.target;
       name = varExpr.name.name;
      // First check in block scopes.
       target = _scope.lookup(name);
       if (target != null) {
-        return target.invoke(this, '\$call', node, _makeArgs(node.arguments));
+        return target.invoke(this, ':call', node, _makeArgs(node.arguments));
       }
 
       target = _makeThisOrType(varExpr.span);
       return target.invoke(this, name, node, _makeArgs(node.arguments));
     } else {
       target = node.target.visit(this);
     }
 
     return target.invoke(this, name, position, _makeArgs(node.arguments));
   }
 
   visitIndexExpression(IndexExpression node) {
     var target = visitValue(node.target);
     var index = visitValue(node.index);
-    return target.invoke(this, '\$index', node, new Arguments(null, [index]));
+    return target.invoke(this, ':index', node, new Arguments(null, [index]));
   }
 
   visitBinaryExpression(BinaryExpression node) {
     final kind = node.op.kind;
     // TODO(jimhug): Ensure these have same semantics as JS!
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitTypedValue(node.x, world.nonNullBool);
       var y = visitTypedValue(node.y, world.nonNullBool);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
@@ skipping 41 matching lines @@
           node.span);
       }
     }
 
     final assignKind = TokenKind.kindFromAssign(node.op.kind);
     if (assignKind == -1) {
       final x = visitValue(node.x);
       final y = visitValue(node.y);
       var name = TokenKind.binaryMethodName(node.op.kind);
       if (node.op.kind == TokenKind.NE) {
-        name = '\$ne';
+        name = ':ne';
       }
       if (name == null) {
         world.internalError('unimplemented binary op ${node.op}', node.span);
         return;
       }
       return x.invoke(this, name, node, new Arguments(null, [y]));
     } else {
       return _visitAssign(assignKind, node.x, node.y, node, null);
     }
   }
@@ skipping 107 matching lines @@
     var target = visitValue(xn.target);
     var index = visitValue(xn.index);
     var y = visitValue(yn);
 
     var tmptarget = target;
     var tmpindex = index;
     if (kind != 0) {
       tmptarget = getTemp(target);
       tmpindex = getTemp(index);
       index = assignTemp(tmpindex, index);
-      var right = tmptarget.invoke(this, '\$index',
+      var right = tmptarget.invoke(this, ':index',
           position, new Arguments(null, [tmpindex]));
       right = captureOriginal(right);
       y = right.invoke(this, TokenKind.binaryMethodName(kind),
           position, new Arguments(null, [y]));
     }
-    var ret = assignTemp(tmptarget, target).invoke(this, '\$setindex',
+    var ret = assignTemp(tmptarget, target).invoke(this, ':setindex',
         position, new Arguments(null, [index, y]));
     if (tmptarget != target) freeTemp(tmptarget);
     if (tmpindex != index) freeTemp(tmpindex);
     return ret;
   }
 
   _visitDotAssign(int kind, DotExpression xn, Expression yn, Node position,
       Value captureOriginal(Value right)) {
 
     // This is not visitValue because types are assignable through .
@@ skipping 42 matching lines @@
           return new Value(newVal.type, '!${newVal.code}', node.span);
         }
 
       case TokenKind.ADD:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         return value.convertTo(this, world.numType, node);
 
       case TokenKind.SUB:
       case TokenKind.BIT_NOT:
         if (node.op.kind == TokenKind.BIT_NOT) {
-          return value.invoke(this, '\$bit_not', node, Arguments.EMPTY);
+          return value.invoke(this, ':bit_not', node, Arguments.EMPTY);
         } else if (node.op.kind == TokenKind.SUB) {
-          return value.invoke(this, '\$negate', node, Arguments.EMPTY);
+          return value.invoke(this, ':negate', node, Arguments.EMPTY);
         } else {
           world.internalError('unimplemented: unary ${node.op}',
             node.span);
         }
       default:
         world.internalError('unimplemented: ${node.op}', node.span);
     }
   }
 
   visitAwaitExpression(AwaitExpression node) {
@@ skipping 419 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }