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

frog/member.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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
   Member method;
 
   String name;
@@ skipping 18 matching lines @@
     }
 
     if (definition.value != null) {
       // To match VM, detect cases where value was not actually specified in
       // code and don't signal errors.
       // TODO(jimhug): Clean up after issue #352 is resolved.
       if (definition.value is NullExpression &&
           definition.value.span.start == definition.span.start) {
         return;
       }
-      if (method.name == '\$call') {
+      if (method.name == ':call') {
         // TODO(jimhug): Need simpler way to detect "true" function types vs.
         //   regular methods being used as function types for closures.
         if (method.definition.body == null) {
           world.error('default value not allowed on function type',
             definition.span);
         }
       } else if (method.isAbstract) {
         world.error('default value not allowed on abstract methods',
           definition.span);
       }
@@ skipping 51 matching lines @@
   bool get isProperty() => false;
   bool get isAbstract() => false;
 
   bool get isFinal() => false;
 
   // TODO(jmesserly): these only makes sense on methods, but because of
   // ConcreteMember we need to support them on Member.
   bool get isConst() => false;
   bool get isFactory() => false;
 
-  bool get isOperator() => name.startsWith('\$');
-  bool get isCallMethod() => name == '\$call';
+  bool get isOperator() => name.startsWith(':');
+  bool get isCallMethod() => name == ':call';
 
   bool get prefersPropertySyntax() => true;
   bool get requiresFieldSyntax() => false;
 
   bool get isNative() => false;
   String get constructorName() {
     world.internalError('can not be a constructor', span);
   }
 
   // Don't display an error here; we'll get a better error later.
@@ skipping 32 matching lines @@
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
   abstract Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
   abstract Value _set(MethodGenerator context, Node node, Value target,
       Value value, [bool isDynamic]);
 
   bool canInvoke(MethodGenerator context, Arguments args) {
     // No source location needed because canInvoke may not produce errors.
     return canGet &&
-      new Value(returnType, null, null).canInvoke(context, '\$call', args);
+      new Value(returnType, null, null).canInvoke(context, ':call', args);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     var newTarget = _get(context, node, target, isDynamic);
-    return newTarget.invoke(context, '\$call', node, args, isDynamic);
+    return newTarget.invoke(context, ':call', node, args, isDynamic);
   }
 
   bool override(Member other) {
     if (isStatic) {
       world.error('static members can not hide parent members',
         span, other.span);
       return false;
     } else if (other.isStatic) {
       world.error('can not override static member', span, other.span);
       return false;
@@ skipping 774 matching lines @@
       return new Value(inferredResult,
         '${declaringType.jsname}.$jsname($argsString)', node.span);
     }
 
     var code = '${target.code}.$jsname($argsString)';
     // optimize expressions which we know statically their value.
     if (target.isConst) {
       if (target is GlobalValue) {
         target = target.dynamic.exp; // TODO: an inline "cast" would be nice.
       }
-      if (name == 'get\$length') {
+      if (name == 'get:length') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.length}';
         }
       } else if (name == 'isEmpty') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.isEmpty()}';
         }
       }
     }
 
     // TODO(jmesserly): factor this better
-    if (name == 'get\$typeName' && declaringType.library == world.dom) {
+    if (name == 'get:typeName' && declaringType.library == world.dom) {
       world.gen.corejs.ensureTypeNameOf();
     }
 
     return new Value(inferredResult, code, node.span);
   }
 
   Value _invokeConstructor(MethodGenerator context, Node node,
       Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
@@ skipping 124 matching lines @@
   Value _invokeBuiltin(MethodGenerator context, Node node, Value target,
       Arguments args, argsCode, bool isDynamic) {
     var allConst = target.isConst && args.values.every((arg) => arg.isConst);
 
     // Handle some fast paths for Number, String, List and DOM.
     if (declaringType.isNum) {
       // TODO(jimhug): This fails in bad ways when argsCode[1] is not num.
       // TODO(jimhug): What about null?
       if (!allConst) {
         var code;
-        if (name == '\$negate') {
+        if (name == ':negate') {
           code = '-${target.code}';
-        } else if (name == '\$bit_not') {
+        } else if (name == ':bit_not') {
           code = '~${target.code}';
-        } else if (name == '\$truncdiv' || name == '\$mod') {
+        } else if (name == ':truncdiv' || name == ':mod') {
           world.gen.corejs.useOperator(name);
-          code = '$name(${target.code}, ${argsCode[0]})';
+          code = '$jsname(${target.code}, ${argsCode[0]})';
         } else {
           var op = TokenKind.rawOperatorFromMethod(name);
           code = '${target.code} $op ${argsCode[0]}';
         }
 
         return new Value(inferredResult, code, node.span);
       } else {
         var value;
         num val0, val1, ival0, ival1;
         val0 = target.dynamic.actualValue;
         ival0 = val0.toInt();
         if (args.values.length > 0) {
           val1 = args.values[0].dynamic.actualValue;
           ival1 = val1.toInt();
         }
         switch (name) {
-          case '\$negate': value = -val0; break;
-          case '\$add': value = val0 + val1; break;
-          case '\$sub': value = val0 - val1; break;
-          case '\$mul': value = val0 * val1; break;
-          case '\$div': value = val0 / val1; break;
-          case '\$truncdiv': value = val0 ~/ val1; break;
-          case '\$mod': value = val0 % val1; break;
-          case '\$eq': value = val0 == val1; break;
-          case '\$lt': value = val0 < val1; break;
-          case '\$gt': value = val0 > val1; break;
-          case '\$lte': value = val0 <= val1; break;
-          case '\$gte': value = val0 >= val1; break;
-          case '\$ne': value = val0 != val1; break;
+          case ':negate': value = -val0; break;
+          case ':add': value = val0 + val1; break;
+          case ':sub': value = val0 - val1; break;
+          case ':mul': value = val0 * val1; break;
+          case ':div': value = val0 / val1; break;
+          case ':truncdiv': value = val0 ~/ val1; break;
+          case ':mod': value = val0 % val1; break;
+          case ':eq': value = val0 == val1; break;
+          case ':lt': value = val0 < val1; break;
+          case ':gt': value = val0 > val1; break;
+          case ':lte': value = val0 <= val1; break;
+          case ':gte': value = val0 >= val1; break;
+          case ':ne': value = val0 != val1; break;
 
           // Note: unfortunatelly bit operations fail on doubles in dartvm
-          case '\$bit_not': value = (~ival0).toDouble(); break;
-          case '\$bit_or': value = (ival0 | ival1).toDouble(); break;
-          case '\$bit_xor': value = (ival0 ^ ival1).toDouble(); break;
-          case '\$bit_and': value = (ival0 & ival1).toDouble(); break;
-          case '\$shl': value = (ival0 << ival1).toDouble(); break;
-          case '\$sar': value = (ival0 >> ival1).toDouble(); break;
-          case '\$shr': value = (ival0 >>> ival1).toDouble(); break;
+          case ':bit_not': value = (~ival0).toDouble(); break;
+          case ':bit_or': value = (ival0 | ival1).toDouble(); break;
+          case ':bit_xor': value = (ival0 ^ ival1).toDouble(); break;
+          case ':bit_and': value = (ival0 & ival1).toDouble(); break;
+          case ':shl': value = (ival0 << ival1).toDouble(); break;
+          case ':sar': value = (ival0 >> ival1).toDouble(); break;
+          case ':shr': value = (ival0 >>> ival1).toDouble(); break;
         }
         return new EvaluatedValue(inferredResult, value, "$value", node.span);
       }
     } else if (declaringType.isString) {
-      if (name == '\$index') {
+      if (name == ':index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         return new Value(declaringType, '${target.code}[${argsCode[0]}]',
           node.span);
-      } else if (name == '\$add') {
+      } else if (name == ':add') {
         if (allConst) {
           final value = _normConcat(target, args.values[0]);
           return new EvaluatedValue(world.stringType, value, value, node.span);
         }
 
         // Ensure we generate toString on the right side
         return new Value(declaringType, '${target.code} + ${argsCode[0]}',
           node.span);
       }
     } else if (declaringType.isNative) {
-      if (name == '\$index') {
+      if (name == ':index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         return new Value(returnType, '${target.code}[${argsCode[0]}]', node.span);
-      } else if (name == '\$setindex') {
+      } else if (name == ':setindex') {
         return new Value(returnType,
           '${target.code}[${argsCode[0]}] = ${argsCode[1]}', node.span);
       }
     }
 
     // TODO(jimhug): Optimize null on lhs as well.
-    if (name == '\$eq' || name == '\$ne') {
-      final op = name == '\$eq' ? '==' : '!=';
+    if (name == ':eq' || name == ':ne') {
+      final op = name == ':eq' ? '==' : '!=';
 
-      if (name == '\$ne') {
+      if (name == ':ne') {
         // Ensure == is generated.
-        target.invoke(context, '\$eq', node, args, isDynamic);
+        target.invoke(context, ':eq', node, args, isDynamic);
       }
 
       if (allConst) {
         var val0 = target.dynamic.actualValue;
         var val1 = args.values[0].dynamic.actualValue;
-        var newVal = name == '\$eq' ? val0 == val1 : val0 != val1;
+        var newVal = name == ':eq' ? val0 == val1 : val0 != val1;
         return new EvaluatedValue(world.nonNullBool,
             newVal, "$newVal", node.span);
       }
       // Optimize test when null is on the rhs.
       if (argsCode[0] == 'null') {
         return new Value(inferredResult, '${target.code} $op null', node.span);
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
         return new Value(inferredResult, '${target.code} $op ${argsCode[0]}',
           node.span);
       }
       world.gen.corejs.useOperator(name);
-      return new Value(inferredResult, '$name(${target.code}, ${argsCode[0]})',
-        node.span);
+      return new Value(inferredResult,
+        '$jsname(${target.code}, ${argsCode[0]})', node.span);
     }
 
     if (isCallMethod) {
       declaringType.markUsed();
       return new Value(inferredResult,
         '${target.code}(${Strings.join(argsCode, ", ")})', node.span);
     }
 
-    if (name == '\$index') {
+    if (name == ':index') {
       world.gen.corejs.useIndex = true;
-    } else if (name == '\$setindex') {
+    } else if (name == ':setindex') {
       world.gen.corejs.useSetIndex = true;
     }
 
     // Fall back to normal method invocation.
     var argsString = Strings.join(argsCode, ', ');
     return new Value(inferredResult, '${target.code}.$jsname($argsString)',
       node.span);
   }
 
   /**
@@ skipping 286 matching lines @@
       // up with a bogus unused temp generated (usually "var $0"). We need a way
       // to throw away temps when we throw away the code.
       returnValue = _tryUnion(returnValue, res, node);
     }
 
     if (returnValue == null) {
       return _makeError(node, target, 'method');
     }
 
     if (returnValue.code == null) {
-      if (name == '\$call') {
+      if (name == ':call') {
         // TODO(jmesserly): reconcile this with similar code in Value
         return target._varCall(context, args);
       } else if (isOperator) {
         // TODO(jmesserly): make operators less special.
-        return target.invokeSpecial(name, args, returnValue.type);
+        return invokeSpecial(target, args, returnValue.type);
       } else {
         return invokeOnVar(context, node, target, args);
       }
     }
 
     return returnValue;
   }
 
+  Value invokeSpecial(Value target, 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, '${target.code}.$jsname($argsString)',
+        target.span);
+    } else {
+      if (argsString.length > 0) argsString = ', $argsString';
+      world.gen.corejs.useOperator(name);
+      return new Value(returnType, '$jsname(${target.code}$argsString)',
+        target.span);
+    }
+  }
+
   Value invokeOnVar(MethodGenerator context, Node node, Value target,
       Arguments args) {
     var member = getVarMember(context, node, args);
     return member.invoke(context, node, target, args);
   }
 
   Value _union(Value x, Value y, Node node) {
     var result = _tryUnion(x, y, node);
     if (result.code == null) {
       world.internalError('mismatched code for $name (${x.code}, ${y.code})',
@@ skipping 116 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }