passing and good perf

frog/lib/corelib_impl.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.
 
 #library("dart:coreimpl");
 
 #source("../../corelib/src/implementation/dual_pivot_quicksort.dart");
 #source("../../corelib/src/implementation/duration_implementation.dart");
 #source("../../corelib/src/implementation/exceptions.dart");
 #source("../../corelib/src/implementation/future_implementation.dart");
@@ skipping 123 matching lines @@
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
     return _array[_pos++];
   }
 
   final List<T> _array;
   int _pos;
 }
 
+// TODO(jimhug): Enforce immutability on IE
+ImmutableList _constList(List other) native '''
+  other.__proto__ = ImmutableList.prototype;
+  return other;
+'''
+{ new ImmutableList(other.length); }
+
+
 /** An immutable list. Attempting to modify the list will throw an exception. */
 class ImmutableList<E> extends ListFactory<E> {
-  final int _length;
-
-  // TODO(sigmund): remove this when we stop overriding the [length] property
-  // in Array.
-  int get length() => _length;
+  // TODO(jimhug): Can this go away now?
+  int get length() native "return this.length;";
 
   void set length(int length) {
     throw const IllegalAccessException();
   }
 
-  ImmutableList([int length]) : _length = length, super(length);
+  ImmutableList(int length) : super(length);
 
   factory ImmutableList.from(List other) {
-    final list = new ImmutableList(other.length);
-    for (int i = 0; i < other.length; i++) {
-      // Note: push invokes the setter of [length], which we override. So
-      // instead we use the native []= operator that cannot be overriden.
-      list._setindex(i, other[i]);
-    }
-    return list;
+    return _constList(other);
   }
 
-  void _setindex(int index, E value) native "return this[index] = value;";
-
   void operator []=(int index, E value) {
     throw const IllegalAccessException();
   }
 
   void copyFrom(List src, int srcStart, int dstStart, int count) {
     throw const IllegalAccessException();
   }
 
   void setRange(int start, int length, List<E> from, [int startFrom = 0]) {
     throw const IllegalAccessException();
@@ skipping 222 matching lines @@
       _done = true;
       return false;
     } else {
       return true;
     }
   }
 }
 
 
 class NumImplementation implements int, double native "Number" {
+  // Arithmetic operations.

[Jennifer Messerly, 2012/01/18 00:03:00]

nice!

+  num operator +(num other) native;
+  num operator -(num other) native;
+  num operator *(num other) native;
+  num operator %(num other) native;
+  num operator /(num other) native;
+  // Truncating division.
+  // TODO(jimhug): Implement
+  num operator ~/(num other) native;
+  // The unary '-' operator.
+  num operator negate() native "'use strict'; return -this;";
+
+  // Relational operations.
+  bool operator <(num other) native;
+  bool operator <=(num other) native;
+  bool operator >(num other) native;
+  bool operator >=(num other) native;
+
+  // Bitwise operations
+  int operator &(int other) native;
+  int operator |(int other) native;
+  int operator ^(int other) native;
+  int operator ~() native;
+  int operator <<(int shiftAmount) native;
+  int operator >>(int shiftAmount) native;
+
+
   // TODO(jimhug): Move these out of methods to avoid boxing when not needed.
   // TODO(jmesserly): for now I'm avoiding boxing with "use strict", however,
   // we might want to do something better. It would be nice if operators and
   // methods on String/num were handled in a uniform way.
   num remainder(num other) native "'use strict'; return this % other;";
 
   bool isEven() native "'use strict'; return ((this & 1) == 0);";
   bool isOdd() native "'use strict'; return ((this & 1) == 1);";
   bool isNaN() native "'use strict'; return isNaN(this);";
   bool isNegative() native
@@ skipping 57 matching lines @@
     } else if (isNaN()) {
       if (other.isNaN()) {
         return 0;
       }
       return 1;
     } else {
       return -1;
     }
   }
 }