Better mangling in frog for fixing parts of issue 1837.

frog/member.dart

 // Copyright (c) 2012, 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 71 matching lines @@
 }
 
 
 class Member extends Element {
   final Type declaringType;
 
   Member genericMember;
 
   Member(String name, Type declaringType)
       : this.declaringType = declaringType,
-        super(name, declaringType);
+        super(name, declaringType) {
+    if (_jsname != null && declaringType.isTop) {
+      _jsname = JsNames.getValid(_jsname);
+    }
+  }
 
   abstract bool get isStatic();
   abstract Type get returnType();
 
   abstract bool get canGet();
   abstract bool get canSet();
 
   Library get library() => declaringType.library;
 
   bool get isPrivate() => name !== null && name.startsWith('_');
@@ skipping 1038 matching lines @@
       var code = null;
       if (args.length == 0) {
         if (name == ':negate') {
           code = '-${target.code}';
         } else if (name == ':bit_not') {
           code = '~${target.code}';
         }
       } else if (args.length == 1 && args.values[0].type.isNum) {
         if (name == ':truncdiv' || name == ':mod') {
           world.gen.corejs.useOperator(name);
-          code = '\$$jsname(${target.code}, ${argsCode[0]})';
+          code = '$jsname\$(${target.code}, ${argsCode[0]})';
         } else {
           var op = TokenKind.rawOperatorFromMethod(name);
           code = '${target.code} $op ${argsCode[0]}';
         }
       }
       if (code !== null) {
         return new Value(inferredResult, code, node.span);
       }
     } else if (target.type.isString) {
       if (name == ':index' && args.values[0].type.isNum) {
@@ skipping 28 matching lines @@
       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);
       // TODO(jimhug): Should be able to use faster path sometimes here!
       return new Value(inferredResult,
-          '\$$jsname(${target.code}, ${argsCode[0]})', node.span);
+          '$jsname\$(${target.code}, ${argsCode[0]})', node.span);
     }
 
     if (isCallMethod) {
       declaringType.markUsed();
       return new Value(inferredResult,
           '${target.code}(${Strings.join(argsCode, ", ")})', node.span);
     }
 
     // TODO(jimhug): Reconcile with MethodSet version - ideally just eliminate
     if (name == ':index') {
       world.gen.corejs.useIndex = true;
     } else if (name == ':setindex') {
       world.gen.corejs.useSetIndex = true;
     } else {
       world.gen.corejs.useOperator(name);
       var argsString = argsCode.length == 0 ? '' : ', ${argsCode[0]}';
-      return new Value(returnType, '\$$jsname(${target.code}${argsString})',
+      return new Value(returnType, '$jsname\$(${target.code}${argsString})',
         node.span);
     }
 
     // Fall back to normal method invocation.
     var argsString = Strings.join(argsCode, ', ');
     return new Value(inferredResult, '${target.code}.$jsname($argsString)',
         node.span);
   }
 
   resolve() {
@@ skipping 159 matching lines @@
         f(member);
       });
     });
   }
 
   bool isEmpty() {
     return factories.getValues()
         .every((Map constructors) => constructors.isEmpty());
   }
 }