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

frog/value.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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 61 matching lines @@
           new Arguments(null, [value]));
     }
   }
 
 
   Value invoke(MethodGenerator context, String name, Node node, Arguments args,
       [bool isDynamic=false]) {
     // TODO(jmesserly): try to get rid of this code path. We're generating a
     // synthetic != on Object (see DefinedType._createNotEqualMember) already.
     // So it should be pretty easy to make this go away.
-    if (_typeIsVarOrParameterType && name == '\$ne') {
+    if (_typeIsVarOrParameterType && name == ':ne') {
       if (args.values.length != 1) {
         world.warning('wrong number of arguments for !=', node.span);
       }
       // Ensure the == operator is generated, and get its type
-      var eq = invoke(context, '\$eq', node, args, isDynamic);
-      world.gen.corejs.useOperator('\$ne');
+      var eq = invoke(context, ':eq', node, args, isDynamic);
+      world.gen.corejs.useOperator(':ne');
       return new Value(eq.type, '\$ne($code, ${args.values[0].code})',
           node.span);
     }
 
     // TODO(jmesserly): it'd be nice to remove these special cases
-    // We could create a $call (and $ne) in world members, and have
+    // We could create a :call (and :ne) in world members, and have
     // those guys handle the canInvoke/Invoke logic.
 
     // Note: this check is a little different than the one in canInvoke, because
-    // sometimes we need to call dynamically even if we found the $call method
+    // sometimes we need to call dynamically even if we found the :call method
     // statically.
 
-    if (name == '\$call') {
+    if (name == ':call') {
       if (isType) {
         world.error('must use "new" or "const" to construct a new instance',
             node.span);
       }
       if (type.needsVarCall(args)) {
         return _varCall(context, args);
       }
     }
 
     var member = _resolveMember(context, name, node, isDynamic);
     if (member == null) {
       return invokeNoSuchMethod(context, name, node, args);
     } else {
       return member.invoke(context, node, this, args, isDynamic);
     }
   }
 
   bool canInvoke(MethodGenerator context, String name, Arguments args) {
     // TODO(jimhug): The != method is weird - understand it better.
-    if (_typeIsVarOrParameterType && name == '\$ne') {
+    if (_typeIsVarOrParameterType && name == ':ne') {
       return true;
     }
 
-    if (type.isVarOrFunction && name == '\$call') {
+    if (type.isVarOrFunction && name == ':call') {
       return true;
     }
 
     var member = _resolveMember(context, name, null, isDynamic:true);
     return member != null && member.canInvoke(context, args);
   }
 
   /**
    * True if this class (or some related class that is not Object) overrides
    * noSuchMethod. If it does we suppress warnings about unknown members.
@@ skipping 371 matching lines @@
         names.add('"${args.getName(i)}", ${args.values[i].code}');
       }
       noSuchArgs.add(new Value(world.gen.useMapFactory(),
           '\$map(${Strings.join(names, ", ")})'));
     }*/
 
     // Finally, invoke noSuchMethod
     return _resolveMember(context, 'noSuchMethod', node).invoke(
         context, node, this, new Arguments(null, noSuchArgs));
   }
-
-  Value invokeSpecial(String name, Arguments args, Type returnType) {
-    assert(name.startsWith('\$'));
-    assert(!args.hasNames);
-    // TODO(jimhug): We need to do this a little bit more like get and set on
-    // properties.  We should check the set of members for something
-    // like "requiresNativeIndexer" and "requiresDartIndexer" to
-    // decide on a strategy.
-
-    var argsString = args.getCode();
-    // Most operator calls need to be emitted as function calls, so we don't
-    // box numbers accidentally. Indexing is the exception.
-    if (name == '\$index' || name == '\$setindex') {
-      return new Value(returnType, '$code.$name($argsString)', span);
-    } else {
-      if (argsString.length > 0) argsString = ', $argsString';
-      world.gen.corejs.useOperator(name);
-      return new Value(returnType, '$name($code$argsString)', span);
-    }
-  }
 }
 
 // TODO(jmesserly): the subtypes of Value require a lot of type checks and
 // downcasts to use; can we make that cleaner? (search for ".dynamic")
 
 /** A value that can has been evaluated statically. */
 class EvaluatedValue extends Value {
 
   var actualValue;
 
@@ skipping 202 matching lines @@
     // Then look for members in my library.
     member = home.library.lookup(name, span);
     if (member != null) {
       return member;
     }
 
     _ensureCode();
     return null;
   }
 }