Avoid mangling the name of native methods.

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) {
-    if (_jsname != null && declaringType != null && declaringType.isTop) {
-      _jsname = JsNames.getValid(_jsname);
+        super(name, declaringType);
+
+  String mangleJsName() {
+    var mangled = super.mangleJsName();
+    if (mangled == 'split') {
+      // Hack: We don't want Dart's String.split to overwrite the
+      // existing JS String.prototype.split method. By mangling it we
+      // ensure that frog will not use the 'split' name, thus leaving
+      // the original JS String.prototype.split untouched.
+      return 'split_';
+    } else if (declaringType != null && declaringType.isTop) {
+      return JsNames.getValid(mangled);
+    } else {
+      // We don't need to mangle native member names unless
+      // they contain illegal characters.
+      return (isNative && !name.contains(':')) ? name : mangled;
     }
   }
 
   abstract bool get isStatic();
   abstract Type get returnType();
 
   abstract bool get canGet();
   abstract bool get canSet();
 
   Library get library() => declaringType.library;
@@ skipping 256 matching lines @@
 /** Represents a Dart field from source code. */
 class FieldMember extends Member {
   final VariableDefinition definition;
   final Expression value;
 
   Type type;
   Value _computedValue;
 
   bool isStatic;
   bool isFinal;
-  bool isNative;
+  final bool isNative;
 
   // TODO(jimhug): Better notion of fields that need special handling...
   bool get overridesProperty() {
     if (isStatic) return false;
 
     if (declaringType.parent != null) {
       var p = declaringType.parent.getProperty(name);
       if (p != null && p.isProperty) return true;
       if (p is FieldMember && p != this) return p.overridesProperty;
     }
@@ skipping 24 matching lines @@
     }
   }
 
   void provideSetter() {
     _provideSetter = true;
     if (genericMember !== null) {
       genericMember.provideSetter();
     }
   }
 
-  FieldMember(String name, Type declaringType, this.definition, this.value)
-      : super(name, declaringType), isNative = false;
+  FieldMember(String name, Type declaringType, this.definition, this.value,
+              [bool this.isNative = false])
+      : super(name, declaringType);
 
   Member makeConcrete(Type concreteType) {
     var ret = new FieldMember(name, concreteType, definition, value);
     ret.genericMember = this;
     ret._jsname = _jsname;
     return ret;
   }
 
-
   SourceSpan get span() => definition == null ? null : definition.span;
 
   Type get returnType() => type;
 
   bool get canGet() => true;
   bool get canSet() => !isFinal;
 
   bool get isField() => true;
 
   resolve() {
@@ skipping 257 matching lines @@
 
   Type _functionType;
   bool isStatic = false;
   bool isAbstract = false;
 
   // Note: these two modifiers are only legal on constructors
   bool isConst = false;
   bool isFactory = false;
 
   /** True if this is a function defined inside another method. */
-  bool isLambda = false;
+  final bool isLambda;
 
   /**
    * True if we should provide info on optional parameters for use by runtime
    * dispatch.
    */
   bool _provideOptionalParamInfo = false;
 
   /*
    * When this is a constructor, contains any other constructor called during
    * initialization (if any).
    */
   Member initDelegate;
 
   MethodMember(String name, Type declaringType, this.definition)
-      : super(name, declaringType);
+      : isLambda = false, super(name, declaringType);
+
+  MethodMember.lambda(String name, Type declaringType, this.definition)
+      : isLambda = true, super(name, declaringType);
 
   Member makeConcrete(Type concreteType) {
     var _name = isConstructor ? concreteType.name : name;
     var ret = new MethodMember(_name, concreteType, definition);
     ret.genericMember = this;
     ret._jsname = _jsname;
     return ret;
   }
 
   MethodData get methodData() {
     if (genericMember !== null) return genericMember.dynamic.methodData;
 
     if (_methodData === null) {
       _methodData = new MethodData(this);
     }
     return _methodData;
   }
 
   bool get isConstructor() => name == declaringType.name;
   bool get isMethod() => !isConstructor;
 
-  bool get isNative() => definition.nativeBody != null;
+  bool get isNative() {
+    if (definition == null) return false;
+    return definition.nativeBody != null;
+  }
 
   bool get canGet() => true;
   bool get canSet() => false;
 
   bool get requiresPropertySyntax() => true;
 
   SourceSpan get span() => definition == null ? null : definition.span;
 
   String get constructorName() {
     var returnType = definition.returnType;
@@ skipping 639 matching lines @@
         f(member);
       });
     });
   }
 
   bool isEmpty() {
     return factories.getValues()
         .every((Map constructors) => constructors.isEmpty());
   }
 }