Add support for the node net module.

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
     Error.captureStackTrace(e, $throw);
   }
@@ skipping 83 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_checkExtends$0", { value: function() {
   return this.noSuchMethod$2("_checkExtends", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_checkNonStatic$1", { value: function($0) {
   return this.noSuchMethod$2("_checkNonStatic", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_evalConstConstructor$2", { value: function($0, $1) {
   return this.noSuchMethod$2("_evalConstConstructor", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "_forEachKey$2", { value: function($0, $1) {
+  return this.noSuchMethod$2("_forEachKey", [$0, $1]);
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$3", { value: function($0, $1, $2) {
   return this.noSuchMethod$2("_get", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$3$isDynamic", { value: function($0, $1, $2, isDynamic) {
   return this.noSuchMethod$2("_get", [$0, $1, $2, isDynamic]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_get$4", { value: function($0, $1, $2, $3) {
   return this.noSuchMethod$2("_get", [$0, $1, $2, $3]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "_pushBlock$1", { value: function($0) {
@@ skipping 70 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "endsWith$1", { value: function($0) {
   return this.noSuchMethod$2("endsWith", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "ensureSubtypeOf$3", { value: function($0, $1, $2) {
   return this.noSuchMethod$2("ensureSubtypeOf", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "evalBody$2", { value: function($0, $1) {
   return this.noSuchMethod$2("evalBody", [$0, $1]);
 }, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "every$1", { value: function($0) {
+  return this.noSuchMethod$2("every", [$0]);
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "filter$1", { value: function($0) {
   return this.noSuchMethod$2("filter", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "findTypeByName$1", { value: function($0) {
   return this.noSuchMethod$2("findTypeByName", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "forEach$1", { value: function($0) {
   return this.noSuchMethod$2("forEach", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "genValue$2", { value: function($0, $1) {
@@ skipping 19 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getLine$1", { value: function($0) {
   return this.noSuchMethod$2("getLine", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getMember$1", { value: function($0) {
   return this.noSuchMethod$2("getMember", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getOrMakeConcreteType$1", { value: function($0) {
   return this.noSuchMethod$2("getOrMakeConcreteType", [$0]);
 }, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "getRange$2", { value: function($0, $1) {
+  return this.noSuchMethod$2("getRange", [$0, $1]);
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "getValues$0", { value: function() {
   return this.noSuchMethod$2("getValues", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "get_$3", { value: function($0, $1, $2) {
   return this.noSuchMethod$2("get_", [$0, $1, $2]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "hasNext$0", { value: function() {
   return this.noSuchMethod$2("hasNext", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "hashCode$0", { value: function() {
@@ skipping 94 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "setDefinition$1", { value: function($0) {
   return this.noSuchMethod$2("setDefinition", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "setIndex$4$kind$returnKind", { value: function($0, $1, $2, $3, kind, returnKind) {
   return this.noSuchMethod$2("setIndex", [$0, $1, $2, $3, kind, returnKind]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "set_$4$kind$returnKind", { value: function($0, $1, $2, $3, kind, returnKind) {
   return this.noSuchMethod$2("set_", [$0, $1, $2, $3, kind, returnKind]);
 }, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(Object.prototype, "some$1", { value: function($0) {
+  return this.noSuchMethod$2("some", [$0]);
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "sort$1", { value: function($0) {
   return this.noSuchMethod$2("sort", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "start$0", { value: function() {
   return this.noSuchMethod$2("start", []);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "startsWith$1", { value: function($0) {
   return this.noSuchMethod$2("startsWith", [$0]);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(Object.prototype, "stop$0", { value: function() {
@@ skipping 129 matching lines @@
   this._functionName = _functionName;
   this._arguments = _arguments;
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = (0);
    i < this._arguments.get$length(); i++) {
     if (i > (0)) {
       sb.add(", ");
     }
-    sb.add(this._arguments[i]);
+    sb.add(this._arguments.$index(i));
   }
   sb.add("]");
   return ("NoSuchMethodException - receiver: '" + this._receiver + "' ") + ("function name: '" + this._functionName + "' arguments: [" + sb + "]");
 }
 NoSuchMethodException.prototype.toString$0 = NoSuchMethodException.prototype.toString;
 // ********** Code for ClosureArgumentMismatchException **************
 function ClosureArgumentMismatchException() {
 
 }
 ClosureArgumentMismatchException.prototype.toString = function() {
@@ skipping 209 matching lines @@
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "isEmpty", { value: function() {
   return this.get$length() == (0);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "iterator", { value: function() {
   return new ListIterator(this);
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "add$1", { value: ListFactory.prototype.add, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "addAll$1", { value: ListFactory.prototype.addAll, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "addLast$1", { value: ListFactory.prototype.addLast, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(ListFactory.prototype, "every$1", { value: function($0) {
+  return this.every(to$call$1($0));
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "filter$1", { value: function($0) {
   return this.filter(to$call$1($0));
 }, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "forEach$1", { value: function($0) {
   return this.forEach(to$call$1($0));
 }, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(ListFactory.prototype, "getRange$2", { value: ListFactory.prototype.getRange, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "indexOf$1", { value: ListFactory.prototype.indexOf, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "isEmpty$0", { value: ListFactory.prototype.isEmpty, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "iterator$0", { value: ListFactory.prototype.iterator, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "last$0", { value: ListFactory.prototype.last, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "removeLast$0", { value: ListFactory.prototype.removeLast, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(ListFactory.prototype, "some$1", { value: function($0) {
+  return this.some(to$call$1($0));
+}, enumerable: false, writable: true, configurable: true });
 Object.defineProperty(ListFactory.prototype, "sort$1", { value: function($0) {
   return this.sort(to$call$2($0));
 }, enumerable: false, writable: true, configurable: true });
 ListFactory_E = ListFactory;
 ListFactory_Expression = ListFactory;
 ListFactory_K = ListFactory;
 ListFactory_dart_core_String = ListFactory;
 ListFactory_V = ListFactory;
 ListFactory_VariableValue = ListFactory;
 ListFactory_int = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = (0);
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.get$length() > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0005);
   }
-  return this._array[this._pos++];
+  return this._array.$index(this._pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for ImmutableList **************
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
@@ skipping 122 matching lines @@
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
@@ skipping 10 matching lines @@
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys[i];
+    var key = oldKeys.$index(i);
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues[i];
+    var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values[index];
+  return this._values.$index(index);
 }
 HashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var index = this._probeForLookup(key);
-  if (index >= (0)) return this._values[index];
+  if (index >= (0)) return this._values.$index(index);
   var value = ifAbsent.call$0();
   this.$setindex(key, value);
   return value;
 }
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
 HashMapImplementation.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    var key = this._keys[i];
+    var key = this._keys.$index(i);
     if ((key != null) && (key != const$0001)) {
-      f.call$2(key, this._values[i]);
+      f.call$2(key, this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 35 matching lines @@
 }
 HashMapImplementation_E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation_E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
@@ skipping 10 matching lines @@
 }
 HashMapImplementation_E$E.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys[i];
+    var key = oldKeys.$index(i);
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues[i];
+    var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_E$E.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation_E$E.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    var key = this._keys[i];
+    var key = this._keys.$index(i);
     if ((key != null) && (key != const$0001)) {
-      f.call$2(key, this._values[i]);
+      f.call$2(key, this._values.$index(i));
     }
   }
 }
 HashMapImplementation_E$E.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 22 matching lines @@
 }
 HashMapImplementation_K$V._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation_K$V.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_K$V.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_K$V.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
@@ skipping 10 matching lines @@
 }
 HashMapImplementation_K$V.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys[i];
+    var key = oldKeys.$index(i);
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues[i];
+    var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_K$V.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_K$V.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values[index];
+  return this._values.$index(index);
 }
 HashMapImplementation_K$V.prototype.putIfAbsent = function(key, ifAbsent) {
   var index = this._probeForLookup(key);
-  if (index >= (0)) return this._values[index];
+  if (index >= (0)) return this._values.$index(index);
   var value = ifAbsent.call$0();
   this.$setindex(key, value);
   return value;
 }
 HashMapImplementation_K$V.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation_K$V.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    var key = this._keys[i];
+    var key = this._keys.$index(i);
     if ((key != null) && (key != const$0001)) {
-      f.call$2(key, this._values[i]);
+      f.call$2(key, this._values.$index(i));
     }
   }
 }
 HashMapImplementation_K$V.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
@@ skipping 28 matching lines @@
 }
 HashMapImplementation_dart_core_String$VariableValue._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
-    var existingKey = this._keys[hash];
+    var existingKey = this._keys.$index(hash);
     if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.get$length() * (2));
     return;
@@ skipping 10 matching lines @@
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
-    var key = oldKeys[i];
+    var key = oldKeys.$index(i);
     if (key == null || key == const$0001) {
       continue;
     }
-    var value = oldValues[i];
+    var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys[index] == null) || (this._keys[index] == const$0001)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
-  return this._values[index];
+  return this._values.$index(index);
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    var key = this._keys[i];
+    var key = this._keys.$index(i);
     if ((key != null) && (key != const$0001)) {
-      f.call$2(key, this._values[i]);
+      f.call$2(key, this._values.$index(i));
     }
   }
 }
 HashMapImplementation_dart_core_String$VariableValue.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != (-1));
 }
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   this._backingMap = new HashMapImplementation_E$E();
 }
@@ skipping 13 matching lines @@
 }
 HashSetImplementation.prototype.addAll = function(collection) {
   var $this = this; // closure support
   collection.forEach(function _(value) {
     $this.add(value);
   }
   );
 }
 HashSetImplementation.prototype.forEach = function(f) {
   this._backingMap.forEach(function _(key, value) {
-    f.call$1(key);
+    f(key);
   }
   );
 }
 HashSetImplementation.prototype.filter = function(f) {
   var result = new HashSetImplementation();
   this._backingMap.forEach(function _(key, value) {
-    if (f.call$1(key)) result.add(key);
+    if (f(key)) result.add(key);
   }
   );
   return result;
 }
 HashSetImplementation.prototype.every = function(f) {
   var keys = this._backingMap.getKeys();
   return keys.every(f);
 }
 HashSetImplementation.prototype.some = function(f) {
   var keys = this._backingMap.getKeys();
   return keys.some(f);
 }
 HashSetImplementation.prototype.isEmpty = function() {
   return this._backingMap.isEmpty();
 }
 HashSetImplementation.prototype.get$length = function() {
   return this._backingMap.get$length();
 }
 HashSetImplementation.prototype.iterator = function() {
   return new HashSetIterator_E(this);
 }
 HashSetImplementation.prototype.add$1 = HashSetImplementation.prototype.add;
 HashSetImplementation.prototype.addAll$1 = HashSetImplementation.prototype.addAll;
 HashSetImplementation.prototype.contains$1 = HashSetImplementation.prototype.contains;
+HashSetImplementation.prototype.every$1 = function($0) {
+  return this.every(to$call$1($0));
+};
 HashSetImplementation.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 HashSetImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 HashSetImplementation.prototype.isEmpty$0 = HashSetImplementation.prototype.isEmpty;
 HashSetImplementation.prototype.iterator$0 = HashSetImplementation.prototype.iterator;
+HashSetImplementation.prototype.some$1 = function($0) {
+  return this.some(to$call$1($0));
+};
 // ********** Code for HashSetImplementation_E **************
 $inherits(HashSetImplementation_E, HashSetImplementation);
 function HashSetImplementation_E() {
   this._backingMap = new HashMapImplementation_E$E();
 }
 // ********** Code for HashSetImplementation_Library **************
 $inherits(HashSetImplementation_Library, HashSetImplementation);
 function HashSetImplementation_Library() {}
 // ********** Code for HashSetImplementation_Member **************
 $inherits(HashSetImplementation_Member, HashSetImplementation);
 function HashSetImplementation_Member() {}
 // ********** Code for HashSetImplementation_dart_core_String **************
 $inherits(HashSetImplementation_dart_core_String, HashSetImplementation);
 function HashSetImplementation_dart_core_String() {}
 // ********** Code for HashSetImplementation_Type **************
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._entries = set_._backingMap._keys;
   this._nextValidIndex = (-1);
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.get$length()) return false;
-  if (this._entries[this._nextValidIndex] == const$0001) {
+  if (this._entries.$index(this._nextValidIndex) == const$0001) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.get$length();
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$0005);
   }
-  var res = this._entries[this._nextValidIndex];
+  var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
   var deletedKey = const$0001;
   do {
     if (++this._nextValidIndex >= length) break;
-    entry = this._entries[this._nextValidIndex];
+    entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry == deletedKey))
 }
 HashSetIterator.prototype.hasNext$0 = HashSetIterator.prototype.hasNext;
 HashSetIterator.prototype.next$0 = HashSetIterator.prototype.next;
 // ********** Code for HashSetIterator_E **************
 $inherits(HashSetIterator_E, HashSetIterator);
 function HashSetIterator_E(set_) {
   this._nextValidIndex = (-1);
   this._entries = set_._backingMap._keys;
   this._advance();
 }
 HashSetIterator_E.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
   var deletedKey = const$0001;
   do {
     if (++this._nextValidIndex >= length) break;
-    entry = this._entries[this._nextValidIndex];
+    entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry == deletedKey))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
 
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.value = value;
   this.key = key;
 }
 KeyValuePair.prototype.get$value = function() { return this.value; };
 KeyValuePair.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for KeyValuePair_K$V **************
 $inherits(KeyValuePair_K$V, KeyValuePair);
 function KeyValuePair_K$V(key, value) {
   this.key = key;
   this.value = value;
 }
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
-  this._map = new HashMapImplementation();
-  this._list = new DoubleLinkedQueue_KeyValuePair_K$V();
+  this._dart_coreimpl_map = new HashMapImplementation();
+  this._dart_coreimpl_list = new DoubleLinkedQueue_KeyValuePair_K$V();
 }
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
-  if (this._map.containsKey(key)) {
-    this._map.$index(key).get$element().set$value(value);
+  if (this._dart_coreimpl_map.containsKey(key)) {
+    this._dart_coreimpl_map.$index(key).get$element().set$value(value);
   }
   else {
-    this._list.addLast(new KeyValuePair_K$V(key, value));
-    this._map.$setindex(key, this._list.lastEntry());
+    this._dart_coreimpl_list.addLast(new KeyValuePair_K$V(key, value));
+    this._dart_coreimpl_map.$setindex(key, this._dart_coreimpl_list.lastEntry());
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
-  var entry = this._map.$index(key);
+  var entry = this._dart_coreimpl_map.$index(key);
   if (entry == null) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var value = this.$index(key);
   if ((this.$index(key) == null) && !(this.containsKey(key))) {
     value = ifAbsent.call$0();
     this.$setindex(key, value);
   }
   return value;
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var index = (0);
-  this._list.forEach(function _(entry) {
+  this._dart_coreimpl_list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
   var list = new Array(this.get$length());
   var index = (0);
-  this._list.forEach(function _(entry) {
+  this._dart_coreimpl_list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
-  this._list.forEach(function _(entry) {
+  this._dart_coreimpl_list.forEach(function _(entry) {
     f.call$2(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
-  return this._map.containsKey(key);
+  return this._dart_coreimpl_map.containsKey(key);
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
-  return this._map.get$length();
+  return this._dart_coreimpl_map.get$length();
 }
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == (0);
 }
 LinkedHashMapImplementation.prototype.containsKey$1 = LinkedHashMapImplementation.prototype.containsKey;
 LinkedHashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 LinkedHashMapImplementation.prototype.getKeys$0 = LinkedHashMapImplementation.prototype.getKeys;
 LinkedHashMapImplementation.prototype.getValues$0 = LinkedHashMapImplementation.prototype.getValues;
@@ skipping 147 matching lines @@
   );
   return counter;
 }
 DoubleLinkedQueue.prototype.isEmpty = function() {
   return (this._sentinel._next == this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    f.call$1(entry._element);
+    f(entry._element);
     entry = nextEntry;
   }
 }
 DoubleLinkedQueue.prototype.every = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (!f.call$1(entry._element)) return false;
+    if (!f(entry._element)) return false;
     entry = nextEntry;
   }
   return true;
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (f.call$1(entry._element)) return true;
+    if (f(entry._element)) return true;
     entry = nextEntry;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
   var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    if (f.call$1(entry._element)) other.addLast(entry._element);
+    if (f(entry._element)) other.addLast(entry._element);
     entry = nextEntry;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator_E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.add$1 = DoubleLinkedQueue.prototype.add;
 DoubleLinkedQueue.prototype.addAll$1 = DoubleLinkedQueue.prototype.addAll;
 DoubleLinkedQueue.prototype.addLast$1 = DoubleLinkedQueue.prototype.addLast;
+DoubleLinkedQueue.prototype.every$1 = function($0) {
+  return this.every(to$call$1($0));
+};
 DoubleLinkedQueue.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.isEmpty$0 = DoubleLinkedQueue.prototype.isEmpty;
 DoubleLinkedQueue.prototype.iterator$0 = DoubleLinkedQueue.prototype.iterator;
 DoubleLinkedQueue.prototype.last$0 = DoubleLinkedQueue.prototype.last;
 DoubleLinkedQueue.prototype.removeLast$0 = DoubleLinkedQueue.prototype.removeLast;
+DoubleLinkedQueue.prototype.some$1 = function($0) {
+  return this.some(to$call$1($0));
+};
 // ********** Code for DoubleLinkedQueue_E **************
 $inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
 function DoubleLinkedQueue_E() {}
 // ********** Code for DoubleLinkedQueue_KeyValuePair_K$V **************
 $inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
 function DoubleLinkedQueue_KeyValuePair_K$V() {
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
-    f.call$1(entry._element);
+    f(entry._element);
     entry = nextEntry;
   }
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next != this._sentinel;
@@ skipping 52 matching lines @@
 }
 StopwatchImplementation.prototype.elapsedInMs$0 = StopwatchImplementation.prototype.elapsedInMs;
 StopwatchImplementation.prototype.start$0 = StopwatchImplementation.prototype.start;
 StopwatchImplementation.prototype.stop$0 = StopwatchImplementation.prototype.stop;
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
-  return this._length;
+  return this._dart_coreimpl_length;
 }
 StringBufferImpl.prototype.isEmpty = function() {
-  return this._length == (0);
+  return this._dart_coreimpl_length == (0);
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString$0();
   if (str == null || str.isEmpty()) return this;
   this._buffer.add(str);
-  this._length = this._length + str.length;
+  this._dart_coreimpl_length = this._dart_coreimpl_length + str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $$i = objects.iterator$0(); $$i.hasNext$0(); ) {
     var obj = $$i.next$0();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new Array();
-  this._length = (0);
+  this._dart_coreimpl_length = (0);
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
   if (this._buffer.get$length() == (0)) return "";
-  if (this._buffer.get$length() == (1)) return this._buffer[(0)];
+  if (this._buffer.get$length() == (1)) return this._buffer.$index((0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 StringBufferImpl.prototype.add$1 = StringBufferImpl.prototype.add;
 StringBufferImpl.prototype.addAll$1 = StringBufferImpl.prototype.addAll;
 StringBufferImpl.prototype.isEmpty$0 = StringBufferImpl.prototype.isEmpty;
 StringBufferImpl.prototype.toString$0 = StringBufferImpl.prototype.toString;
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     charCodes = new ListFactory.ListFactory$from$factory(charCodes);
   }
   return String.fromCharCode.apply(null, charCodes);
 }
 StringBase.join = function(strings, separator) {
   if (strings.get$length() == (0)) return "";
-  var s = strings[(0)];
+  var s = strings.$index((0));
   for (var i = (1);
    i < strings.get$length(); i++) {
-    s = s + separator + strings[i];
+    s = s + separator + strings.$index(i);
   }
   return s;
 }
 StringBase.concatAll = function(strings) {
   return StringBase.join(strings, "");
 }
 // ********** Code for StringImplementation **************
 StringImplementation = String;
 StringImplementation.prototype.get$length = function() { return this.length; };
 StringImplementation.prototype.endsWith = function(other) {
@@ skipping 71 matching lines @@
 StringImplementation.prototype.isEmpty$0 = StringImplementation.prototype.isEmpty;
 StringImplementation.prototype.replaceFirst$2 = StringImplementation.prototype.replaceFirst;
 StringImplementation.prototype.startsWith$1 = StringImplementation.prototype.startsWith;
 StringImplementation.prototype.substring$1 = StringImplementation.prototype.substring;
 StringImplementation.prototype.substring$2 = StringImplementation.prototype.substring;
 // ********** Code for Collections **************
 function Collections() {}
 Collections.forEach = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    f.call$1(e);
+    f(e);
   }
 }
 Collections.some = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (f.call$1(e)) return true;
+    if (f(e)) return true;
   }
   return false;
 }
 Collections.every = function(iterable, f) {
   for (var $$i = iterable.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (!f.call$1(e)) return false;
+    if (!f(e)) return false;
   }
   return true;
 }
 Collections.filter = function(source, destination, f) {
   for (var $$i = source.iterator$0(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
-    if (f.call$1(e)) destination.add(e);
+    if (f(e)) destination.add(e);
   }
   return destination;
 }
 // ********** Code for _Worker **************
 // ********** Code for _ArgumentMismatchException **************
 $inherits(_ArgumentMismatchException, ClosureArgumentMismatchException);
 function _ArgumentMismatchException(_message) {
   this._dart_coreimpl_message = _message;
   ClosureArgumentMismatchException.call(this);
 }
@@ skipping 69 matching lines @@
 }
 // ********** Code for top level **************
 function _constList(other) {
     other.__proto__ = ImmutableList.prototype;
     return other;
 }
 function _map(itemsAndKeys) {
   var ret = new LinkedHashMapImplementation();
   for (var i = (0);
    i < itemsAndKeys.get$length(); ) {
-    ret.$setindex(itemsAndKeys[i++], itemsAndKeys[i++]);
+    ret.$setindex(itemsAndKeys.$index(i++), itemsAndKeys.$index(i++));
   }
   return ret;
 }
-//  ********** Library node **************
-// ********** Code for Process **************
-function Process(_process) {
-  this.SIGSYS = "SIGSYS";
-  this.SIGALRM = "SIGALRM";
-  this.SIGXCPU = "SIGXCPU";
-  this.SIGTSTP = "SIGTSTP";
-  this.SIGSEGV = "SIGSEGV";
-  this.SIGQUIT = "SIGQUIT";
-  this.SIGABRT = "SIGABRT";
-  this.SIGKILL = "SIGKILL";
-  this.SIGHUP = "SIGHUP";
-  this.SIGUSR2 = "SIGUSR2";
-  this.SIGXFSZ = "SIGXFSZ";
-  this.SIGCONT = "SIGCONT";
-  this.SIGTTOU = "SIGTTOU";
-  this.SIGINT = "SIGINT";
-  this.SIGURG = "SIGURG";
-  this.SIGFPE = "SIGFPE";
-  this.SIGUSR1 = "SIGUSR1";
-  this.SIGEMT = "SIGEMT";
-  this.SIGPIPE = "SIGPIPE";
-  this.SIGTTIN = "SIGTTIN";
-  this.SIGTERM = "SIGTERM";
-  this._process = _process;
-  this.SIGBUS = "SIGBUS";
-  this.SIGPROF = "SIGPROF";
-  this.SIGSTOP = "SIGSTOP";
-  this.SIGCHLD = "SIGCHLD";
-  this.SIGILL = "SIGILL";
-  this.SIGTRAP = "SIGTRAP";
-  this.SIGINFO = "SIGINFO";
-  this.SIGIO = "SIGIO";
-  this.SIGVTALRM = "SIGVTALRM";
-  this.SIGWINCH = "SIGWINCH";
+//  ********** Library nodeimpl **************
+// ********** Code for NativeMapBase **************
+function NativeMapBase(_map) {
+  this._map = _map;
 }
-Process.prototype.get$argv = function() {
-  return this._process.argv;
+NativeMapBase.prototype.get$length = function() {
+  return this._length(this._map);
 }
-Process.prototype.set$argv = function(value) {
-  this._process.argv = value;
+NativeMapBase.prototype._length = function(map) {
+  return map.length;
 }
-Process.prototype.get$env = function() {
-  return new EnvMap(this._process);
+NativeMapBase.prototype.isEmpty = function() {
+  return this.get$length() == (0);
 }
-Process.prototype.exit = function(code) {
-  this._process.exit(code);
+NativeMapBase.prototype.getKeys = function() {
+  var keys = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return keys.add(key);
+  })
+  );
+  return keys;
 }
-// ********** Code for EnvMap **************
-function EnvMap(_process) {
-  this._process = _process;
+NativeMapBase.prototype.getValues = function() {
+  var $this = this; // closure support
+  var values = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return values.add($this.$index(key));
+  })
+  );
+  return values;
 }
-EnvMap.prototype.$index = function(key) {
-  return this._process.env[key];
+NativeMapBase.prototype.forEach = function(f) {
+  var $this = this; // closure support
+  return this._forEachKey$2(this._map, (function (k) {
+    return f.call$2(k, $this.$index(k));
+  })
+  );
 }
-// ********** Code for ReadableStream **************
-// ********** Code for WritableStream **************
+NativeMapBase.prototype._forEachKey = function(map, f) {
+        for (var i in map) {
+          if (map.hasOwnProperty(i)) {
+            f(i);
+          }
+        }
+      
+}
+NativeMapBase.prototype._forEachKey$2 = function($0, $1) {
+  return this._forEachKey($0, to$call$1($1));
+};
+NativeMapBase.prototype.forEach$1 = function($0) {
+  return this.forEach(to$call$2($0));
+};
+NativeMapBase.prototype.getKeys$0 = NativeMapBase.prototype.getKeys;
+NativeMapBase.prototype.getValues$0 = NativeMapBase.prototype.getValues;
+NativeMapBase.prototype.isEmpty$0 = NativeMapBase.prototype.isEmpty;
+// ********** Code for NativeMapBase_dart_core_String **************
+$inherits(NativeMapBase_dart_core_String, NativeMapBase);
+function NativeMapBase_dart_core_String(_map) {
+  this._map = _map;
+}
+NativeMapBase_dart_core_String.prototype.getKeys = function() {
+  var keys = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return keys.add(key);
+  })
+  );
+  return keys;
+}
+NativeMapBase_dart_core_String.prototype.getValues = function() {
+  var $this = this; // closure support
+  var values = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return values.add($this.$index(key));
+  })
+  );
+  return values;
+}
+NativeMapBase_dart_core_String.prototype.forEach = function(f) {
+  var $this = this; // closure support
+  return this._forEachKey$2(this._map, (function (k) {
+    return f.call$2(k, $this.$index(k));
+  })
+  );
+}
+NativeMapBase_dart_core_String.prototype._forEachKey = function(map, f) {
+        for (var i in map) {
+          if (map.hasOwnProperty(i)) {
+            f(i);
+          }
+        }
+      
+}
+// ********** Code for NativeMapBase_V **************
+$inherits(NativeMapBase_V, NativeMapBase);
+function NativeMapBase_V(_map) {
+  this._map = _map;
+}
+NativeMapBase_V.prototype.getKeys = function() {
+  var keys = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return keys.add(key);
+  })
+  );
+  return keys;
+}
+NativeMapBase_V.prototype.getValues = function() {
+  var $this = this; // closure support
+  var values = new Array();
+  this._forEachKey$2(this._map, (function (key) {
+    return values.add($this.$index(key));
+  })
+  );
+  return values;
+}
+NativeMapBase_V.prototype.forEach = function(f) {
+  var $this = this; // closure support
+  return this._forEachKey$2(this._map, (function (k) {
+    return f.call$2(k, $this.$index(k));
+  })
+  );
+}
+NativeMapBase_V.prototype._forEachKey = function(map, f) {
+        for (var i in map) {
+          if (map.hasOwnProperty(i)) {
+            f(i);
+          }
+        }
+      
+}
+// ********** Code for NativeMapPrimitiveValue **************
+$inherits(NativeMapPrimitiveValue, NativeMapBase_V);
+function NativeMapPrimitiveValue(map) {
+  NativeMapBase_V.call(this, map);
+}
+NativeMapPrimitiveValue.prototype.$index = function(key) {
+  return this._at(this._map, key);
+}
+NativeMapPrimitiveValue.prototype._at = function(map, key) {
+  return map[key];
+}
+// ********** Code for NativeMapPrimitiveValue_dart_core_String **************
+$inherits(NativeMapPrimitiveValue_dart_core_String, NativeMapPrimitiveValue);
+function NativeMapPrimitiveValue_dart_core_String(map) {
+  NativeMapBase_dart_core_String.call(this, map);
+}
+NativeMapPrimitiveValue_dart_core_String.prototype.$index = function(key) {
+  return this._at(this._map, key);
+}
+NativeMapPrimitiveValue_dart_core_String.prototype._at = function(map, key) {
+  return map[key];
+}
+// ********** Code for top level **************
+//  ********** Library fs **************
+// ********** Code for fs_ReadStream **************
+// ********** Code for fs_WriteStream **************
 Object.defineProperty(Object.prototype, '$typeNameOf', { value: function() {
   if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')
       || typeof(process) != 'undefined') { // fast-path for Chrome and Node
     return this.constructor.name;
   }
   var str = Object.prototype.toString.call(this);
   str = str.substring(8, str.length - 1);
   if (str == 'Window') {
     str = 'DOMWindow';
   } else if (str == 'Document') {
@@ skipping 51 matching lines @@
       map[tagNames[j]] = true;
     }
     table.push({tag: tag, tags: tags, map: map});
   }
   $dynamicMetadata = table;
 }
 $dynamic("get$end").WriteStream = function() {
   return this.end.bind(this);
 }
 $dynamic("end$0").WriteStream = function() {
-  return this.end(null, "utf8");
+  return this.end();
 };
 $dynamic("write$1").WriteStream = function($0) {
   return this.write($0, "utf8");
 };
-// ********** Code for vm **************
-vm = require('vm');
-// ********** Code for fs **************
-fs = require('fs');
-// ********** Code for path **************
-path = require('path');
+// ********** Code for fs_FSWatcher **************
+// ********** Code for top level **************
+function get$fs() {
+  return require("fs");
+}
+//  ********** Library node **************
+// ********** Code for Process **************
+function Process(_process) {
+  this.SIGSYS = "SIGSYS";
+  this.SIGALRM = "SIGALRM";
+  this.SIGXCPU = "SIGXCPU";
+  this.SIGTSTP = "SIGTSTP";
+  this.SIGSEGV = "SIGSEGV";
+  this.SIGQUIT = "SIGQUIT";
+  this.SIGABRT = "SIGABRT";
+  this.SIGKILL = "SIGKILL";
+  this.SIGHUP = "SIGHUP";
+  this.SIGUSR2 = "SIGUSR2";
+  this.SIGXFSZ = "SIGXFSZ";
+  this.SIGCONT = "SIGCONT";
+  this.SIGTTOU = "SIGTTOU";
+  this.SIGINT = "SIGINT";
+  this.SIGURG = "SIGURG";
+  this.SIGFPE = "SIGFPE";
+  this.SIGUSR1 = "SIGUSR1";
+  this.SIGEMT = "SIGEMT";
+  this.SIGPIPE = "SIGPIPE";
+  this.SIGTTIN = "SIGTTIN";
+  this.SIGTERM = "SIGTERM";
+  this._process = _process;
+  this.SIGBUS = "SIGBUS";
+  this.SIGPROF = "SIGPROF";
+  this.SIGSTOP = "SIGSTOP";
+  this.SIGCHLD = "SIGCHLD";
+  this.SIGILL = "SIGILL";
+  this.SIGTRAP = "SIGTRAP";
+  this.SIGINFO = "SIGINFO";
+  this.SIGIO = "SIGIO";
+  this.SIGVTALRM = "SIGVTALRM";
+  this.SIGWINCH = "SIGWINCH";
+}
+Process.prototype.get$argv = function() {
+  return this._process.argv;
+}
+Process.prototype.set$argv = function(value) {
+  this._process.argv = value;
+}
+Process.prototype.get$env = function() {
+  return new _EnvMap(this._env());
+}
+Process.prototype._env = function() {
+  return this._process.env;
+}
+Process.prototype.exit = function(code) {
+  this._process.exit(code);
+}
+// ********** Code for _EnvMap **************
+$inherits(_EnvMap, NativeMapPrimitiveValue_dart_core_String);
+function _EnvMap(env) {
+  NativeMapPrimitiveValue_dart_core_String.call(this, env);
+}
+_EnvMap.prototype._node_forEachKey = function(map, f) {
+         for (var i in map) {
+           f(i);
+         }
+       
+}
 // ********** Code for top level **************
 function createSandbox() {
-  return {'require': require, 'process': process, 'console': console,
+  return {
+        'require': require,
+        'process': process,
+        'console': console,
         'Buffer' : Buffer,
-        'setTimeout': setTimeout, 'clearTimeout': clearTimeout};
+        'setTimeout': setTimeout,
+        'clearTimeout': clearTimeout,
+        'setInterval': setInterval,
+        'clearInterval': clearInterval,
+        'module' : module,
+        'ArrayBuffer': ArrayBuffer,
+        'Int8Array': Int8Array,
+        'Uint8Array': Uint8Array,
+        'Int16Array': Int16Array,
+        'Uint16Array': Uint16Array,
+        'Int32Array': Int32Array,
+        'Uint32Array': Uint32Array,
+        'Float32Array': Float32Array,
+        'Float64Array': Float64Array,
+        'DataView': DataView
+        };
 }
 function get$_process() {
   return process;
 }
 function get$process() {
   return new Process(get$_process());
 }
+//  ********** Library path **************
+// ********** Code for path **************
+path = require('path');
+// ********** Code for top level **************
+//  ********** Library vm **************
+// ********** Code for vm **************
+vm = require('vm');
+// ********** Code for top level **************
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function canonicalizePath(path) {
   return path.replaceAll("\\", "/");
 }
 function joinPaths(path1, path2) {
   path1 = canonicalizePath(path1);
   path2 = canonicalizePath(path2);
   var pieces = path1.split("/");
   var $$list = path2.split("/");
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var piece = $$list[$$i];
+    var piece = $$list.$index($$i);
     if ($eq(piece, "..") && pieces.get$length() > (0) && $ne(pieces.last$0(), ".") && $ne(pieces.last$0(), "..")) {
       pieces.removeLast$0();
     }
     else if ($ne(piece, "")) {
       if (pieces.get$length() > (0) && $eq(pieces.last$0(), ".")) {
         pieces.removeLast$0();
       }
       pieces.add$1(piece);
     }
   }
@@ skipping 18 matching lines @@
   else {
     return path.substring(lastSlash + (1));
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
 
 }
 NodeFileSystem.prototype.writeString = function(outfile, text) {
-  fs.writeFileSync(outfile, text);
+  get$fs().writeFileSync(outfile, text, "utf8");
 }
 NodeFileSystem.prototype.readAll = function(filename) {
-  return fs.readFileSync(filename, "utf8");
+  return get$fs().readFileSync(filename, "utf8");
 }
 NodeFileSystem.prototype.fileExists = function(filename) {
   return path.existsSync(filename);
 }
 // ********** Code for top level **************
 //  ********** Library lang **************
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, node, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this._vars = new CopyOnWriteMap_dart_core_String$VariableValue();
@@ skipping 313 matching lines @@
   else {
     if (this.useWrap0) {
       w.writeln("function $wrap_call$0(fn) { return fn; }");
     }
     if (this.useWrap1) {
       w.writeln("function $wrap_call$1(fn) { return fn; }");
     }
   }
   var $$list = orderValuesByKeys(this._usedOperators);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var opImpl = $$list[$$i];
+    var opImpl = $$list.$index($$i);
     w.writeln(opImpl);
   }
   if ($globals.world.dom != null) {
     this.ensureTypeNameOf();
     w.writeln("Object.defineProperty(Object.prototype, \"get$typeName\", { value: Object.prototype.$typeNameOf, enumerable: false, writable: true, configurable: true});");
   }
 }
 CoreJs.prototype.generate$1 = CoreJs.prototype.generate;
 // ********** Code for Element **************
 function Element(name, _enclosingElement) {
@@ skipping 42 matching lines @@
   var $0;
   return (this._enclosingElement = ($0 = e), $0);
 }
 Element.prototype.resolveType = function(node, typeErrors) {
   if (node == null) return $globals.world.varType;
   if (node.type != null) return node.type;
   if ((node instanceof NameTypeReference)) {
     var typeRef = node;
     var name;
     if (typeRef.names != null) {
-      name = typeRef.names.last().get$name();
+      name = typeRef.names.last$0().get$name();
     }
     else {
       name = typeRef.name.name;
     }
     if (this.get$typeParameters() != null) {
       var $$list = this.get$typeParameters();
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var tp = $$list[$$i];
+        var tp = $$list.$index($$i);
         if ($eq(tp.get$name(), name)) {
           typeRef.type = tp;
         }
       }
     }
     if (typeRef.type != null) {
       return typeRef.type;
     }
     return this.get$enclosingElement().resolveType$2(node, typeErrors);
   }
   else if ((node instanceof GenericTypeReference)) {
     var typeRef = node;
     var baseType = this.resolveType$2(typeRef.baseType, typeErrors);
     if (!baseType.get$isGeneric()) {
       $globals.world.error(("" + baseType.get$name() + " is not generic"), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.get$length() != baseType.get$typeParameters().get$length()) {
       $globals.world.error("wrong number of type arguments", typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = (0);
      i < typeRef.typeArguments.get$length(); i++) {
-      typeArgs.add$1(this.resolveType$2(typeRef.typeArguments[i], typeErrors));
+      typeArgs.add$1(this.resolveType$2(typeRef.typeArguments.$index(i), typeErrors));
     }
     typeRef.type = baseType.getOrMakeConcreteType$1(typeArgs);
   }
   else if ((node instanceof FunctionTypeReference)) {
     var typeRef = node;
     var name = "";
     if (typeRef.func.name != null) {
       name = typeRef.func.name.name;
     }
     typeRef.type = this.get$library().getOrAddFunctionType(this, name, typeRef.func);
@@ skipping 60 matching lines @@
   this.writeGlobals();
   this.writer.writeln(("" + mainCall.get$code() + ";"));
 }
 WorldGenerator.prototype.markLibrariesUsed = function(libs) {
   return this.getAllTypes(libs).forEach(this.get$markTypeUsed());
 }
 WorldGenerator.prototype.markTypeUsed = function(type) {
   if (!type.get$isClass()) return;
   type.markUsed();
   type.isTested = true;
-  type.isTested = !type.get$isTop() && !(type.get$isNative() && type.get$members().getValues().every((function (m) {
+  type.isTested = !type.get$isTop() && !(type.get$isNative() && type.get$members().getValues$0().every$1((function (m) {
     return m.get$isStatic() && !m.get$isFactory();
   })
   ));
-  var members = ListFactory.ListFactory$from$factory(type.get$members().getValues());
-  members.addAll$1(type.get$constructors().getValues());
+  var members = ListFactory.ListFactory$from$factory(type.get$members().getValues$0());
+  members.addAll$1(type.get$constructors().getValues$0());
   type.get$factories().forEach((function (f) {
     return members.add$1(f);
   })
   );
   for (var $$i = members.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if ((member instanceof PropertyMember)) {
       if (member.get$getter() != null) this.genMethod(member.get$getter());
       if (member.get$setter() != null) this.genMethod(member.get$setter());
     }
     if ((member instanceof MethodMember)) this.genMethod(member);
   }
 }
 WorldGenerator.prototype.get$markTypeUsed = function() {
   return this.markTypeUsed.bind(this);
 }
 WorldGenerator.prototype.getAllTypes = function(libs) {
   var types = [];
   var seen = new HashSetImplementation();
   for (var $$i = 0;$$i < libs.get$length(); $$i++) {
-    var mainLib = libs[$$i];
+    var mainLib = libs.$index($$i);
     var toCheck = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([mainLib]);
     while (!toCheck.isEmpty()) {
       var lib = toCheck.removeFirst();
       if (seen.contains(lib)) continue;
       seen.add(lib);
       lib.get$imports().forEach$1((function (lib, toCheck, i) {
         return toCheck.addLast(lib);
       }).bind(null, lib, toCheck)
       );
       lib.get$types().getValues$0().forEach$1((function (t) {
@@ skipping 24 matching lines @@
     ret = new GlobalValue(exp.get$type(), name, true, null, name, exp, exp.span, dependencies);
     this.globals.$setindex(key, ret);
   }
   return ret;
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if (lib.isWritten) return;
   lib.isWritten = true;
   var $$list = lib.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var import_ = $$list[$$i];
+    var import_ = $$list.$index($$i);
     this.writeTypes(import_.get$library());
   }
   for (var i = (0);
    i < lib.sources.get$length(); i++) {
-    lib.sources[i].set$orderInLibrary(i);
+    lib.sources.$index(i).set$orderInLibrary(i);
   }
   this.writer.comment(("//  ********** Library " + lib.name + " **************"));
   if (lib.get$isCore()) {
     this.writer.comment("//  ********** Natives dart:core **************");
     this.corejs.generate(this.writer);
   }
   var $$list = lib.natives;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var file = $$list[$$i];
+    var file = $$list.$index($$i);
     var filename = basename(file.get$filename());
     this.writer.comment(("//  ********** Natives " + filename + " **************"));
     this.writer.writeln(file.get$text());
   }
   lib.topType.markUsed();
   var orderedTypes = this._orderValues(lib.types);
   for (var $$i = orderedTypes.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     if ((type.get$library().get$isDom() || type.get$isHiddenNativeType()) && type.get$isClass()) {
       type.markUsed$0();
     }
   }
   for (var $$i = orderedTypes.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     if (type.get$isUsed() && type.get$isClass()) {
       this.writeType(type);
       if (type.get$isGeneric()) {
         var $$list = this._orderValues(type.get$_concreteTypes());
         for (var $i0 = 0;$i0 < $$list.get$length(); $i0++) {
-          var ct = $$list[$i0];
+          var ct = $$list.$index($i0);
           this.writeType(ct);
         }
       }
     }
     else if (type.get$isFunction() && type.get$varStubs().get$length() > (0)) {
       this.writer.comment(("// ********** Code for " + type.get$jsname() + " **************"));
       this._writeDynamicStubs(type);
     }
     if (type.get$typeCheckCode() != null) {
       this.writer.writeln(type.get$typeCheckCode());
@@ skipping 114 matching lines @@
   else {
     var standardConstructor = type.get$constructors().$index("");
     if (standardConstructor == null || standardConstructor.generator == null) {
       if (!type.get$isNative()) {
         this.writer.writeln(("function " + type.get$jsname() + "() {}"));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
-    var $$list = type.get$constructors().getValues();
+    var $$list = type.get$constructors().getValues$0();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
       var c = $$i.next$0();
       if (c.get$generator() != null && $ne(c, standardConstructor)) {
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
   }
   if (type.get$genericType()._concreteTypes != null) {
     var $$list = this._orderValues(type.get$genericType()._concreteTypes);
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var ct = $$list[$$i];
+      var ct = $$list.$index($$i);
       this._maybeIsTest(type, ct);
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll$1(type.get$interfaces());
     seen.addAll$1(type.get$interfaces());
     while (!worklist.isEmpty$0()) {
       var interface_ = worklist.removeLast$0();
       this._maybeIsTest(type, interface_.get$genericType());
       if (interface_.get$genericType().get$_concreteTypes() != null) {
         var $$list = this._orderValues(interface_.get$genericType().get$_concreteTypes());
         for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-          var ct = $$list[$$i];
+          var ct = $$list.$index($$i);
           this._maybeIsTest(type, ct);
         }
       }
       var $$list = interface_.get$interfaces();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var other = $$i.next$0();
         if (!seen.contains$1(other)) {
           worklist.addLast$1(other);
           seen.add$1(other);
         }
       }
     }
   }
   type.get$factories().forEach(this.get$_writeMethod());
   var $$list = this._orderValues(type.get$members());
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var member = $$list[$$i];
+    var member = $$list.$index($$i);
     if ((member instanceof FieldMember)) {
       this._writeField(member);
     }
     if ((member instanceof PropertyMember)) {
       this._writeProperty(member);
     }
     if (member.get$isMethod()) {
       this._writeMethod(member);
     }
   }
   this._writeDynamicStubs(type);
 }
 WorldGenerator.prototype._typeNeedsHolderForStaticMethods = function(type) {
-  var $$list = type.get$members().getValues();
+  var $$list = type.get$members().getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if (member.get$isMethod()) {
       if (member.get$isConstructor() || member.get$isStatic()) {
         if (member.get$isGenerated()) {
           return true;
         }
       }
     }
   }
   return false;
 }
 WorldGenerator.prototype._ensureInheritMembersHelper = function() {
   if (this._mixins != null) return;
   this._mixins = new CodeWriter();
   this._mixins.comment("// ********** Generic Type Inheritance **************");
   this._mixins.writeln("/** Implements extends for generic types. */\nfunction $inheritsMembers(child, parent) {\n  child = child.prototype;\n  parent = parent.prototype;\n  Object.getOwnPropertyNames(parent).forEach(function(name) {\n    if (typeof(child[name]) == 'undefined') child[name] = parent[name];\n  });\n}");
 }
 WorldGenerator.prototype._writeDynamicStubs = function(type) {
   var $$list = orderValuesByKeys(type.varStubs);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var stub = $$list[$$i];
+    var stub = $$list.$index($$i);
     if (!stub.get$isGenerated()) stub.generate$1(this.writer);
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
   if (field.isFinal) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
   if (this.globals.containsKey(fullname)) {
     var value = this.globals.$index(fullname);
     if (field.declaringType.get$isTop() && !field.isNative) {
       this.writer.writeln(("$globals." + field.get$jsname() + " = " + value.get$exp().get$code() + ";"));
@@ skipping 36 matching lines @@
   else if ((m instanceof MethodMember) && m.get$isNative() && m._providePropertySyntax && !m._provideFieldSyntax) {
     MethodGenerator._maybeGenerateBoundGetter(m, this.writer);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return this._writeMethod.bind(this);
 }
 WorldGenerator.prototype.writeGlobals = function() {
   if (this.globals.get$length() > (0)) {
     this.writer.comment("//  ********** Globals **************");
-    var list = this.globals.getValues();
+    var list = this.globals.getValues$0();
     list.sort$1((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     this.writer.enterBlock("function $static_init(){");
     for (var $$i = list.iterator$0(); $$i.hasNext$0(); ) {
       var global = $$i.next$0();
       if (global.get$field() != null) {
         this._writeStaticField(global.get$field());
       }
@@ skipping 23 matching lines @@
   var $this = this; // closure support
   if (this.typesWithDynamicDispatch == null) return;
   this.writer.comment(("// " + this.typesWithDynamicDispatch.get$length() + " dynamic types."));
   var seen = new HashSetImplementation();
   var types = [];
   function visit(type) {
     if (seen.contains$1(type)) return;
     seen.add$1(type);
     var $$list = $this._orderCollectionValues(type.get$directSubtypes());
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var subtype = $$list[$$i];
-      visit.call$1(subtype);
+      var subtype = $$list.$index($$i);
+      visit(subtype);
     }
     types.add$1(type);
   }
   var $$list = this._orderCollectionValues(this.typesWithDynamicDispatch);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var type = $$list[$$i];
-    visit.call$1(type);
+    var type = $$list.$index($$i);
+    visit(type);
   }
   var dispatchTypes = types.filter$1((function (type) {
     return !type.get$directSubtypes().isEmpty$0() && $this.typesWithDynamicDispatch.contains(type);
   })
   );
   this.writer.comment(("// " + types.get$length() + " types"));
   this.writer.comment(("// " + types.filter$1((function (t) {
     return !t.get$directSubtypes().isEmpty$0();
   })
   ).get$length() + " !leaf"));
   var varNames = [];
   var varDefns = new HashMapImplementation();
   var tagDefns = new HashMapImplementation();
   function makeExpression(type) {
     var expressions = [];
     var subtags = [type.get$nativeName()];
     function walk(type) {
       var $$list = $this._orderCollectionValues(type.get$directSubtypes());
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var subtype = $$list[$$i];
+        var subtype = $$list.$index($$i);
         var tag = subtype.get$nativeName();
         var existing = tagDefns.$index(tag);
         if (existing == null) {
           subtags.add$1(tag);
-          walk.call$1(subtype);
+          walk(subtype);
         }
         else {
           if (varDefns.containsKey$1(existing)) {
             expressions.add$1(existing);
           }
           else {
             var varName = ("v" + varNames.get$length() + "/*" + tag + "*/");
             varNames.add$1(varName);
             varDefns.$setindex(varName, existing);
             tagDefns.$setindex(tag, varName);
             expressions.add$1(varName);
           }
         }
       }
     }
-    walk.call$1(type);
+    walk(type);
     var constantPart = ("'" + Strings.join(subtags, "|") + "'");
     if ($ne(constantPart, "''")) expressions.add$1(constantPart);
     var expression;
     if ($eq(expressions.get$length(), (1))) {
       expression = expressions.$index((0));
     }
     else {
       expression = ("[" + Strings.join(expressions, ",") + "].join('|')");
     }
     return expression;
   }
   for (var $$i = dispatchTypes.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
-    tagDefns.$setindex(type.get$nativeName(), makeExpression.call$1(type));
+    tagDefns.$setindex(type.get$nativeName(), makeExpression(type));
   }
   if (!tagDefns.isEmpty$0()) {
     this.writer.enterBlock("(function(){");
     for (var $$i = varNames.iterator$0(); $$i.hasNext$0(); ) {
       var varName = $$i.next$0();
       this.writer.writeln(("var " + varName + " = " + varDefns.$index(varName) + ";"));
     }
     this.writer.enterBlock("var table = [");
     this.writer.comment("// [dynamic-dispatch-tag, tags of classes implementing dynamic-dispatch-tag]");
     for (var $$i = dispatchTypes.iterator$0(); $$i.hasNext$0(); ) {
       var type = $$i.next$0();
       this.writer.writeln(("['" + type.get$nativeName() + "', " + tagDefns.$index(type.get$nativeName()) + "],"));
     }
     this.writer.exitBlock("];");
     this.writer.writeln("$dynamicSetMetadata(table);");
     this.writer.exitBlock("})();");
   }
 }
 WorldGenerator.prototype._orderValues = function(map) {
-  var values = map.getValues();
+  var values = map.getValues$0();
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._orderCollectionValues = function(collection) {
   var values = ListFactory.ListFactory$from$factory(collection);
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
   if (x.get$span() != null && y.get$span() != null) {
@@ skipping 44 matching lines @@
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return value.get$needsTemp() ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
   if (this._freeTemps.get$length() > (0)) {
-    name = this._freeTemps.removeLast();
+    name = this._freeTemps.removeLast$0();
   }
   else {
     name = "$" + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
   return new VariableValue(value.get$staticType(), name, value.span, false, value);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
   if ($eq(tmp, v)) {
     return v;
@@ skipping 13 matching lines @@
   if (this.method.get$isConstructor()) {
     thisObject = new ObjectValue(false, this.method.declaringType, this.method.get$span());
     thisObject.initFields$0();
   }
   else {
     thisObject = new Value(this.method.declaringType, "this", null);
   }
   var values = [];
   var $$list = this.method.get$parameters();
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list[$$i];
+    var p = $$list.$index($$i);
     values.add$1(new Value(p.get$type(), p.get$name(), null));
   }
   var args = new Arguments(null, values);
   this.evalBody(thisObject, args);
   if (this.method.get$definition().get$nativeBody() != null) {
     this.writer = new CodeWriter();
     if ($eq(this.method.get$definition().get$nativeBody(), "")) {
       this.method.generator = null;
     }
     else {
@@ skipping 97 matching lines @@
 }
 MethodGenerator.prototype._provideOptionalParamInfo = function(defWriter) {
   if ((this.method instanceof MethodMember)) {
     var meth = this.method;
     if (meth._provideOptionalParamInfo) {
       var optNames = [];
       var optValues = [];
       meth.genParameterValues();
       var $$list = meth.parameters;
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var param = $$list[$$i];
+        var param = $$list.$index($$i);
         if (param.get$isOptional()) {
           optNames.add$1(param.get$name());
           optValues.add$1(MethodGenerator._escapeString(param.get$value().get$code()));
         }
       }
       if (optNames.get$length() > (0)) {
         var start = "";
         if (meth.isStatic) {
           if (!meth.declaringType.get$isTop()) {
             start = meth.declaringType.get$jsname() + ".";
@@ skipping 20 matching lines @@
   return newObject.setField(field, value, true);
 }
 MethodGenerator.prototype.evalBody = function(newObject, args) {
   var fieldsSet = false;
   if (this.method.get$isNative() && this.method.get$isConstructor() && (newObject instanceof ObjectValue)) {
     newObject.get$dynamic().set$seenNativeInitializer(true);
   }
   this._paramCode = [];
   for (var i = (0);
    i < this.method.get$parameters().get$length(); i++) {
-    var p = this.method.get$parameters()[i];
+    var p = this.method.get$parameters().$index(i);
     var currentArg = null;
     if (i < args.get$bareCount()) {
-      currentArg = args.values[i];
+      currentArg = args.values.$index(i);
     }
     else {
       currentArg = args.getValue(p.get$name());
       if (currentArg == null) {
         p.genValue$2(this.method, this.method.generator);
         currentArg = p.get$value();
       }
     }
     if (p.get$isInitializer()) {
       this._paramCode.add(p.get$name());
@@ skipping 122 matching lines @@
     var value = m.invoke$4(this, node, target, newArgs);
     if ($ne(target.get$type(), $globals.world.objectType)) {
       this.writer.writeln(("" + value.get$code() + ";"));
     }
   }
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var args = [];
   var seenLabel = false;
   for (var $$i = 0;$$i < arguments.get$length(); $$i++) {
-    var arg = arguments[$$i];
+    var arg = arguments.$index($$i);
     if (arg.get$label() != null) {
       seenLabel = true;
     }
     else if (seenLabel) {
       $globals.world.error("bare argument can not follow named arguments", arg.get$span());
     }
     args.add$1(this.visitValue(arg.get$value()));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator.prototype._invokeNative = function(name, arguments) {
   var args = Arguments.get$EMPTY();
   if (arguments.get$length() > (0)) {
     args = new Arguments(null, arguments);
   }
   var method = $globals.world.corelib.topType.members.$index(name);
   return method.invoke$4(this, method.get$definition(), new Value($globals.world.corelib.topType, null, null), args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r");
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
   if ((body instanceof BlockStatement)) {
     var block = body;
     var $$list = block.body;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var stmt = $$list[$$i];
+      var stmt = $$list.$index($$i);
       stmt.visit$1(this);
     }
   }
   else {
     if (body != null) body.visit(this);
   }
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(node, reentrant) {
   this._scope = new BlockScope(this, this._scope, node, reentrant);
 }
 MethodGenerator.prototype._popBlock = function(node) {
   if (this._scope.node != node) {
     function spanOf(n) {
       return n != null ? n.get$span() : null;
     }
-    $globals.world.internalError(("scope mismatch. Trying to pop \"" + node + "\" but found ") + (" \"" + this._scope.node + "\""), spanOf.call$1(node), spanOf.call$1(this._scope.node));
+    $globals.world.internalError(("scope mismatch. Trying to pop \"" + node + "\" but found ") + (" \"" + this._scope.node + "\""), spanOf(node), spanOf(this._scope.node));
   }
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._visitLoop = function(node, visitBody) {
   if (this._scope.inferTypes) {
     this._loopFixedPoint(node, visitBody);
   }
   else {
     this._pushBlock(node, true);
     visitBody.call$0();
@@ skipping 58 matching lines @@
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
   var parser = new Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
-  if (node.modifiers != null && $eq(node.modifiers[(0)].get$kind(), (99))) {
+  if (node.modifiers != null && $eq(node.modifiers.$index((0)).get$kind(), (99))) {
     isFinal = true;
   }
   this.writer.write("var ");
   var type = this.method.resolveType$2(node.type, false);
   for (var i = (0);
    i < node.names.get$length(); i++) {
     if (i > (0)) {
       this.writer.write(", ");
     }
-    var name = node.names[i].get$name();
-    var value = this.visitValue(node.values[i]);
+    var name = node.names.$index(i).get$name();
+    var value = this.visitValue(node.values.$index(i));
     if (isFinal && value == null) {
       $globals.world.error("no value specified for final variable", node.span);
     }
-    var val = this._scope.create(name, type, node.names[i].get$span(), isFinal, false);
+    var val = this._scope.create(name, type, node.names.$index(i).get$span(), isFinal, false);
     if (value == null) {
       if (this._scope.reentrant) {
         this.writer.write(("" + val.get$code() + " = null"));
       }
       else {
         this.writer.write(("" + val.get$code()));
       }
     }
     else {
       value = value.convertTo$2(this, type);
@@ skipping 121 matching lines @@
     if (node.test != null) {
       var test = $this.visitBool(node.test);
       $this.writer.write((" " + test.get$code() + "; "));
     }
     else {
       $this.writer.write("; ");
     }
     var needsComma = false;
     var $$list = node.step;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var s = $$list[$$i];
+      var s = $$list.$index($$i);
       if (needsComma) $this.writer.write(", ");
       var sv = $this.visitVoid(s);
       $this.writer.write(sv.get$code());
       needsComma = true;
     }
     $this.writer.write(") ");
     $this._pushBlock(node.body, false);
     node.body.visit($this);
     $this._popBlock(node.body);
   })
@@ skipping 51 matching lines @@
 MethodGenerator.prototype._genStackTraceOf = function(trace, ex) {
   var result = this._invokeNative("_stackTraceOf", [ex]);
   this.writer.writeln(("var " + trace.get$code() + " = " + result.get$code() + ";"));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock("try {");
   this._pushBlock(node.body, false);
   this.visitStatementsInBlock(node.body);
   this._popBlock(node.body);
   if (node.catches.get$length() == (1)) {
-    var catch_ = node.catches[(0)];
+    var catch_ = node.catches.$index((0));
     this._pushBlock(catch_, false);
     var exType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
     var ex = this._scope.declare(catch_.get$exception());
     this._scope.rethrow = ex.get$code();
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     if (catch_.get$trace() != null) {
       var trace = this._scope.declare(catch_.get$trace());
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     if (!exType.get$isVarOrObject()) {
       var test = ex.instanceOf$3$isTrue$forceCheck(this, exType, catch_.get$exception().get$span(), false, true);
       this.writer.writeln(("if (" + test.get$code() + ") throw " + ex.get$code() + ";"));
     }
-    this.visitStatementsInBlock(node.catches[(0)].get$body());
+    this.visitStatementsInBlock(node.catches.$index((0)).get$body());
     this._popBlock(catch_);
   }
   else if (node.catches.get$length() > (0)) {
     this._pushBlock(node, false);
     var ex = this._scope.create("$ex", $globals.world.varType, null, false, false);
     this._scope.rethrow = ex.get$code();
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     var trace = null;
     if (node.catches.some((function (c) {
       return c.get$trace() != null;
     })
     )) {
       trace = this._scope.create("$trace", $globals.world.varType, null, false, false);
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     var needsRethrow = true;
     for (var i = (0);
      i < node.catches.get$length(); i++) {
-      var catch_ = node.catches[i];
+      var catch_ = node.catches.$index(i);
       this._pushBlock(catch_, false);
       var tmpType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
       var tmp = this._scope.declare(catch_.get$exception());
       if (!tmpType.get$isVarOrObject()) {
         var test = ex.instanceOf$3$isTrue$forceCheck(this, tmpType, catch_.get$exception().get$span(), true, true);
         if (i == (0)) {
           this.writer.enterBlock(("if (" + test.get$code() + ") {"));
         }
         else {
           this.writer.nextBlock(("} else if (" + test.get$code() + ") {"));
         }
       }
       else if (i > (0)) {
         this.writer.nextBlock("} else {");
       }
       this.writer.writeln(("var " + tmp.get$code() + " = " + ex.get$code() + ";"));
       if (catch_.get$trace() != null) {
         var tmptrace = this._scope.declare(catch_.get$trace());
         this.writer.writeln(("var " + tmptrace.get$code() + " = " + trace.get$code() + ";"));
       }
       this.visitStatementsInBlock(catch_.get$body());
       this._popBlock(catch_);
       if (tmpType.get$isVarOrObject()) {
         if (i + (1) < node.catches.get$length()) {
-          $globals.world.error("Unreachable catch clause", node.catches[i + (1)].get$span());
+          $globals.world.error("Unreachable catch clause", node.catches.$index(i + (1)).get$span());
         }
         if (i > (0)) {
           this.writer.exitBlock("}");
         }
         needsRethrow = false;
         break;
       }
     }
     if (needsRethrow) {
       this.writer.nextBlock("} else {");
       this.writer.writeln(("throw " + ex.get$code() + ";"));
       this.writer.exitBlock("}");
     }
     this._popBlock(node);
   }
   if (node.finallyBlock != null) {
     this.writer.nextBlock("} finally {");
     this._pushBlock(node.finallyBlock, false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock(node.finallyBlock);
   }
   this.writer.exitBlock("}");
   return false;
 }
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
   var test = this.visitValue(node.test);
   this.writer.enterBlock(("switch (" + test.get$code() + ") {"));
   var $$list = node.cases;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var case_ = $$list[$$i];
+    var case_ = $$list.$index($$i);
     if (case_.get$label() != null) {
       $globals.world.error("unimplemented: labeled case statement", case_.get$span());
     }
     this._pushBlock(case_, false);
     for (var i = (0);
      i < case_.get$cases().get$length(); i++) {
       var expr = case_.get$cases().$index(i);
       if (expr == null) {
         if (i < case_.get$cases().get$length() - (1)) {
           $globals.world.error("default clause must be the last case", case_.get$span());
         }
         this.writer.writeln("default:");
       }
       else {
         var value = this.visitValue(expr);
         this.writer.writeln(("case " + value.get$code() + ":"));
       }
     }
     this.writer.enterBlock("");
     var caseExits = this._visitAllStatements(case_.get$statements(), false);
-    if ($ne(case_, node.cases[node.cases.get$length() - (1)]) && !caseExits) {
+    if ($ne(case_, node.cases.$index(node.cases.get$length() - (1))) && !caseExits) {
       var span = case_.get$statements().$index(case_.get$statements().get$length() - (1)).get$span();
       this.writer.writeln("$throw(new FallThroughError());");
       $globals.world.gen.corejs.useThrow = true;
     }
     this.writer.exitBlock("");
     this._popBlock(case_);
   }
   this.writer.exitBlock("}");
   return false;
 }
@@ skipping 273 matching lines @@
     }
     $globals.world.error(("no matching constructor for " + name), node.span);
     return this._makeMissingValue(name);
   }
   if (node.isConst) {
     if (!m.get$isConst()) {
       $globals.world.error("can't use const on a non-const constructor", node.span);
     }
     var $$list = node.arguments;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var arg = $$list[$$i];
+      var arg = $$list.$index($$i);
       if (!this.visitValue(arg.get$value()).get$isConst()) {
         $globals.world.error("const constructor expects const arguments", arg.get$span());
       }
     }
   }
   var target = new TypeValue(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argValues = [];
   var listType = $globals.world.listType;
   var type = $globals.world.varType;
   if (node.itemType != null) {
     type = this.method.resolveType$2(node.itemType, true);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const list literals");
     }
     listType = listType.getOrMakeConcreteType$1([type]);
   }
   var $$list = node.values;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var item = $$list[$$i];
+    var item = $$list.$index($$i);
     var arg = this.visitTypedValue(item, type);
     argValues.add$1(arg);
     if (node.isConst && !arg.get$isConst()) {
       $globals.world.error("const list can only contain const values", arg.get$span());
     }
   }
   $globals.world.listFactoryType.markUsed();
   var ret = new ListValue(argValues, node.isConst, listType, node.span);
   if (ret.get$isConst()) return ret.getGlobalValue$0();
   return ret;
@@ skipping 16 matching lines @@
       }
     }
     valueType = this.method.resolveType$2(node.valueType, true);
     if (node.isConst && ((valueType instanceof ParameterType) || valueType.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const map literals");
     }
     mapType = mapType.getOrMakeConcreteType$1([keyType, valueType]);
   }
   for (var i = (0);
    i < node.items.get$length(); i += (2)) {
-    var key = this.visitTypedValue(node.items[i], keyType);
+    var key = this.visitTypedValue(node.items.$index(i), keyType);
     if (node.isConst && !key.get$isConst()) {
       $globals.world.error("const map can only contain const keys", key.get$span());
     }
     values.add$1(key);
-    var value = this.visitTypedValue(node.items[i + (1)], valueType);
+    var value = this.visitTypedValue(node.items.$index(i + (1)), valueType);
     if (node.isConst && !value.get$isConst()) {
       $globals.world.error("const map can only contain const values", value.get$span());
     }
     values.add$1(value);
   }
   var ret = new MapValue(values, node.isConst, mapType, node.span);
   if (ret.get$isConst()) return ret.getGlobalValue$0();
   return ret;
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
@@ skipping 43 matching lines @@
     return u.op.kind == (16) || u.op.kind == (17);
   }
   else {
     return false;
   }
 }
 MethodGenerator.prototype.visitStringInterpExpression = function(node) {
   var items = [];
   var $$list = node.pieces;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var item = $$list[$$i];
+    var item = $$list.$index($$i);
     var val = this.visitValue(item);
     val.invoke$4(this, "toString", item, Arguments.get$EMPTY());
     var code = val.get$code();
     if (this._expressionNeedsParens(item)) {
       code = ("(" + code + ")");
     }
     if ($eq(items.get$length(), (0)) || ($ne(code, "''") && $ne(code, "\"\""))) {
       items.add$1(code);
     }
   }
@@ skipping 59 matching lines @@
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
 Arguments.prototype.get$hasNames = function() {
   return this.get$bareCount() < this.get$length();
 }
 Arguments.prototype.get$length = function() {
   return this.values.get$length();
 }
 Arguments.prototype.getName = function(i) {
-  return this.nodes[i].get$label().get$name();
+  return this.nodes.$index(i).get$label().get$name();
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     if (this.getName(i) == name) {
       return i;
     }
   }
   return (-1);
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
-  return i >= (0) ? this.values[i] : null;
+  return i >= (0) ? this.values.$index(i) : null;
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
       for (var i = (0);
        i < this.nodes.get$length(); i++) {
-        if (this.nodes[i].get$label() != null) {
+        if (this.nodes.$index(i).get$label() != null) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = (0);
    i < this.get$length(); i++) {
-    argsCode.add$1(this.values[i].get$code());
+    argsCode.add$1(this.values.$index(i).get$code());
   }
   Arguments.removeTrailingNulls(argsCode);
   return Strings.join(argsCode, ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
-  while (argsCode.get$length() > (0) && $eq(argsCode.last(), "null")) {
-    argsCode.removeLast();
+  while (argsCode.get$length() > (0) && $eq(argsCode.last$0(), "null")) {
+    argsCode.removeLast$0();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     names.add$1(this.getName(i));
   }
   return names;
 }
@@ skipping 284 matching lines @@
 Library.prototype._addMember = function(member) {
   if (member.get$isPrivate()) {
     if (member.get$isStatic()) {
       if (member.declaringType.get$isTop()) {
         $globals.world._addTopName(member);
       }
       return;
     }
     var mset = this._privateMembers.$index(member.name);
     if (mset == null) {
-      var $$list = $globals.world.libraries.getValues();
+      var $$list = $globals.world.libraries.getValues$0();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var lib = $$i.next$0();
         if (lib.get$_privateMembers().containsKey$1(member.get$jsname())) {
           member._jsname = ("_" + this.get$jsname() + member.get$jsname());
           break;
         }
       }
       mset = new MemberSet(member, true);
       this._privateMembers.$setindex(member.name, mset);
     }
@@ skipping 33 matching lines @@
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if (result == null) return null;
   if (type.names != null) {
     if (type.names.get$length() > (1)) {
       return null;
     }
     if (!result.get$isTop()) {
       return null;
     }
-    return result.get$library().findTypeByName(type.names[(0)].get$name());
+    return result.get$library().findTypeByName(type.names.$index((0)).get$name());
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name) {
   var ret = this.types.$index(name);
   var $$list = this.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var imported = $$list[$$i];
+    var imported = $$list.$index($$i);
     var newRet = null;
     if (imported.get$prefix() == null) {
       newRet = imported.get$library().get$types().$index(name);
     }
     else if ($eq(imported.get$prefix(), name)) {
       newRet = imported.get$library().get$topType();
     }
     if (newRet != null) {
       if (ret != null && $ne(ret, newRet)) {
         $globals.world.error(("conflicting types for \"" + name + "\""), ret.get$span(), newRet.get$span());
@@ skipping 43 matching lines @@
     var index = this.name.lastIndexOf("/", this.name.length);
     if (index >= (0)) {
       this.name = this.name.substring($add(index, (1)));
     }
     index = this.name.indexOf(".");
     if (index > (0)) {
       this.name = this.name.substring((0), index);
     }
   }
   this._jsname = this.name.replaceAll(".", "_").replaceAll(":", "_").replaceAll(" ", "_");
-  var $$list = this.types.getValues();
+  var $$list = this.types.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     type.resolve$0();
   }
 }
 Library.prototype._addTopName = function(name, member, localSpan) {
   var existing = this._topNames.$index(name);
   if (existing == null) {
     this._topNames.$setindex(name, member);
   }
   else {
     if ((existing instanceof AmbiguousMember)) {
       existing.get$members().add$1(member);
     }
     else {
       var newMember = new AmbiguousMember(name, [existing, member]);
       $globals.world.error(("conflicting members for \"" + name + "\""), existing.get$span(), member.get$span(), localSpan);
       this._topNames.$setindex(name, newMember);
     }
   }
 }
 Library.prototype._addTopNames = function(lib) {
-  var $$list = lib.topType.members.getValues();
+  var $$list = lib.topType.members.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     if (member.get$isPrivate() && $ne(lib, this)) continue;
     this._addTopName(member.get$name(), member);
   }
-  var $$list = lib.types.getValues();
+  var $$list = lib.types.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     if (!type.get$isTop()) {
       if ($ne(lib, this) && type.get$typeMember().get$isPrivate()) continue;
       this._addTopName(type.get$name(), type.get$typeMember());
     }
   }
 }
 Library.prototype.postResolveChecks = function() {
   this._topNames = new HashMapImplementation();
   this._addTopNames(this);
   var $$list = this.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var imported = $$list[$$i];
+    var imported = $$list.$index($$i);
     if (imported.get$prefix() == null) {
       this._addTopNames(imported.get$library());
     }
     else {
       this._addTopName(imported.get$prefix(), imported.get$library().get$topType().get$typeMember(), imported.get$span());
     }
   }
 }
 Library.prototype.visitSources = function() {
   var visitor = new _LibraryVisitor(this);
@@ skipping 150 matching lines @@
 _LibraryVisitor.prototype.getSingleStringArg = function(node) {
   if (node.arguments.get$length() != (1)) {
     $globals.world.error(("expected exactly one argument but found " + node.arguments.get$length()), node.span);
   }
   return this.getFirstStringArg(node);
 }
 _LibraryVisitor.prototype.getFirstStringArg = function(node) {
   if (node.arguments.get$length() < (1)) {
     $globals.world.error(("expected at least one argument but found " + node.arguments.get$length()), node.span);
   }
-  var arg = node.arguments[(0)];
+  var arg = node.arguments.$index((0));
   if (arg.get$label() != null) {
     $globals.world.error("label not allowed for directive", node.span);
   }
   return this._parseStringArgument(arg);
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var args = node.arguments.filter$1((function (a) {
     return a.get$label() != null && $eq(a.get$label().get$name(), argName);
   })
   );
@@ skipping 13 matching lines @@
   if (!(expr instanceof LiteralExpression) || !expr.get$value().get$type().get$isString()) {
     $globals.world.error("expected string literal", expr.get$span());
   }
   return expr.get$value().get$actualValue();
 }
 _LibraryVisitor.prototype.visitTypeDefinition = function(node) {
   var oldType = this.currentType;
   this.currentType = this.library.addType(node.name.name, node, node.isClass);
   var $$list = node.body;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var member = $$list[$$i];
+    var member = $$list.$index($$i);
     member.visit$1(this);
   }
   this.currentType = oldType;
 }
 _LibraryVisitor.prototype.visitVariableDefinition = function(node) {
   this.currentType.addField(node);
 }
 _LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
@@ skipping 171 matching lines @@
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var mod = $$list[$$i];
+      var mod = $$list.$index($$i);
       if ($eq(mod.get$kind(), (85))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($eq(mod.get$kind(), (99))) {
         if (this.isFinal) {
           $globals.world.error("duplicate final modifier", mod.get$span());
         }
@@ skipping 211 matching lines @@
 PropertyMember.prototype.resolve$0 = PropertyMember.prototype.resolve;
 // ********** Code for ConcreteMember **************
 $inherits(ConcreteMember, Member);
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   Member.call(this, name, declaringType);
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $$list = this.baseMember.get$parameters();
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list[$$i];
+    var p = $$list.$index($$i);
     var newType = p.get$type().resolveTypeParams$1(declaringType);
     if ($ne(newType, p.get$type())) {
       this.parameters.add(p.copyWithNewType$2(this, newType));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
@@ skipping 203 matching lines @@
     return false;
   }
 }
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
   if (bareCount > this.parameters.get$length()) return false;
   if (bareCount == this.parameters.get$length()) {
     if (bareCount != args.get$length()) return false;
   }
   else {
-    if (!this.parameters[bareCount].get$isOptional()) return false;
+    if (!this.parameters.$index(bareCount).get$isOptional()) return false;
     for (var i = bareCount;
      i < args.get$length(); i++) {
       if (this.indexOfParameter(args.getName(i)) < (0)) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name) {
   for (var i = (0);
    i < this.parameters.get$length(); i++) {
-    var p = this.parameters[i];
+    var p = this.parameters.$index(i);
     if (p.get$isOptional() && $eq(p.get$name(), name)) {
       return i;
     }
   }
   return (-1);
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
@@ skipping 13 matching lines @@
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ("" + target.get$code() + ".get$" + this.get$jsname() + "()"), node.span);
 }
 MethodMember.prototype.namesInHomePositions = function(args) {
   if (!args.get$hasNames()) return true;
   for (var i = args.get$bareCount();
    i < args.values.get$length(); i++) {
     if (i >= this.parameters.get$length()) {
       return false;
     }
-    if (args.getName(i) != this.parameters[i].get$name()) {
+    if (args.getName(i) != this.parameters.$index(i).get$name()) {
       return false;
     }
   }
   return true;
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!args.get$hasNames()) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
    i < this.parameters.get$length(); i++) {
-    var p = args.getIndexOfName(this.parameters[i].get$name());
-    if (p >= (0) && args.values[p].get$needsTemp()) {
+    var p = args.getIndexOfName(this.parameters.$index(i).get$name());
+    if (p >= (0) && args.values.$index(p).get$needsTemp()) {
       if (lastParameter != null && lastParameter > p) {
         return false;
       }
       lastParameter = p;
     }
   }
   return true;
 }
 MethodMember.prototype.needsArgumentConversion = function(args) {
   var bareCount = args.get$bareCount();
   for (var i = (0);
    i < bareCount; i++) {
-    var arg = args.values[i];
-    if (arg.needsConversion$1(this.parameters[i].get$type())) {
+    var arg = args.values.$index(i);
+    if (arg.needsConversion$1(this.parameters.$index(i).get$type())) {
       return true;
     }
   }
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
-      var arg = args.getValue(this.parameters[i].get$name());
-      if (arg != null && arg.needsConversion$1(this.parameters[i].get$type())) {
+      var arg = args.getValue(this.parameters.$index(i).get$name());
+      if (arg != null && arg.needsConversion$1(this.parameters.$index(i).get$type())) {
         return true;
       }
     }
   }
   return false;
 }
 MethodMember._argCountMsg = function(actual, expected, atLeast) {
   return "wrong number of positional arguments, expected " + ("" + (atLeast ? "at least " : "") + expected + " but found " + actual);
 }
 MethodMember.prototype._argError = function(context, node, target, args, msg, argIndex) {
   var span;
   if ((args.nodes == null) || (argIndex >= args.nodes.get$length())) {
     span = node.span;
   }
   else {
-    span = args.nodes[argIndex].get$span();
+    span = args.nodes.$index(argIndex).get$span();
   }
   if (this.isStatic || this.get$isConstructor()) {
     $globals.world.error(msg, span);
   }
   else {
     $globals.world.warning(msg, span);
   }
   return target.invokeNoSuchMethod(context, this.name, node, args);
 }
 MethodMember.prototype.genParameterValues = function() {
   var $$list = this.parameters;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list[$$i];
+    var p = $$list.$index($$i);
     p.genValue$2(this, this.generator);
   }
 }
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.parameters == null) {
     $globals.world.info(("surprised to need to resolve: " + this.declaringType.name + "." + this.name));
     this.resolve();
   }
   this.declaringType.genMethod(this);
   if (this.isStatic || this.isFactory) {
     this.declaringType.markUsed();
   }
   if (this.get$isNative() && this.returnType != null) this.returnType.markUsed();
   if (!this.namesInOrder(args)) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
   if (!target.get$isType() && (this.get$isConstructor() || target.get$isSuper())) {
     argsCode.add$1("this");
   }
   var bareCount = args.get$bareCount();
   for (var i = (0);
    i < bareCount; i++) {
-    var arg = args.values[i];
+    var arg = args.values.$index(i);
     if (i >= this.parameters.get$length()) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.get$length(), false);
       return this._argError(context, node, target, args, msg, i);
     }
-    arg = arg.convertTo$3(context, this.parameters[i].get$type(), isDynamic);
+    arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
     argsCode.add$1(arg.get$code());
   }
   var namedArgsUsed = (0);
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
-      var arg = args.getValue(this.parameters[i].get$name());
+      var arg = args.getValue(this.parameters.$index(i).get$name());
       if (arg == null) {
-        arg = this.parameters[i].get$value();
+        arg = this.parameters.$index(i).get$value();
       }
       else {
-        arg = arg.convertTo$3(context, this.parameters[i].get$type(), isDynamic);
+        arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
         namedArgsUsed++;
       }
-      if (arg == null || !this.parameters[i].get$isOptional()) {
+      if (arg == null || !this.parameters.$index(i).get$isOptional()) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + (1), true);
         return this._argError(context, node, target, args, msg, i);
       }
       else {
         argsCode.add$1(arg.get$code());
       }
     }
     Arguments.removeTrailingNulls(argsCode);
   }
   if (namedArgsUsed < args.get$nameCount()) {
@@ skipping 135 matching lines @@
   return new Value(this.get$inferredResult(), ("" + target.get$code() + "." + this.get$jsname() + "(" + argsString + ")"), node.span);
 }
 MethodMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !this.declaringType.get$isClass();
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var mod = $$list[$$i];
+      var mod = $$list.$index($$i);
       if ($eq(mod.get$kind(), (85))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
       else if (this.get$isConstructor() && $eq(mod.get$kind(), (92))) {
         if (this.isConst) {
           $globals.world.error("duplicate const modifier", mod.get$span());
         }
@@ skipping 51 matching lines @@
   }
   if (this.get$isConstructor() && !this.isFactory) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = this.resolveType(this.definition.returnType, false, true);
   }
   this.parameters = [];
   var $$list = this.definition.formals;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var formal = $$list[$$i];
+    var formal = $$list.$index($$i);
     var param = new Parameter(formal, this);
     param.resolve$0();
     this.parameters.add(param);
   }
   if (!this.isLambda) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.resolveType = function(node, typeErrors, allowVoid) {
   var t = Element.prototype.resolveType.call(this, node, typeErrors);
@@ skipping 37 matching lines @@
 MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
 MemberSet.prototype.get$isVar = function() { return this.isVar; };
 MemberSet.prototype.toString = function() {
   return ("" + this.name + ":" + this.members.get$length());
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
-  return this.members.get$length() == (1) && this.members[(0)].get$isStatic();
+  return this.members.get$length() == (1) && this.members.$index((0)).get$isStatic();
 }
 MemberSet.prototype.get$isOperator = function() {
-  return this.members[(0)].get$isOperator();
+  return this.members.$index((0)).get$isOperator();
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if (!target.get$type().get$isVar()) {
     $globals.world.warning(("could not find applicable " + action + " for \"" + this.name + "\""), node.span);
   }
   return new Value($globals.world.varType, ("" + target.get$code() + "." + this.jsname + "() /*no applicable " + action + "*/"), node.span);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if (this._treatAsField == null) {
     this._treatAsField = !this.isVar && (this.members.some((function (m) {
       return m.get$requiresFieldSyntax();
     })
     ) || this.members.every((function (m) {
       return !m.get$requiresPropertySyntax();
     })
     ));
     var $$list = this.members;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var member = $$list[$$i];
+      var member = $$list.$index($$i);
       if (this._treatAsField) {
         member.provideFieldSyntax$0();
       }
       else {
         member.providePropertySyntax$0();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
   var returnValue;
   if (this.members.get$length() == (1) && !this.isVar) {
-    return this.members[(0)]._get$4(context, node, target, isDynamic);
+    return this.members.$index((0))._get$4(context, node, target, isDynamic);
   }
   var targets = this.members.filter$1((function (m) {
     return m.get$canGet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._get$3$isDynamic(context, node, target, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span);
   }
   else {
     if (this.members.get$length() == (1)) {
-      return this.members[(0)]._get$4(context, node, target, isDynamic);
+      return this.members.$index((0))._get$4(context, node, target, isDynamic);
     }
     else if ($eq(targets.get$length(), (1))) {
       return targets.$index((0))._get$4(context, node, target, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
       var value = member._get$3$isDynamic(context, node, target, true);
       returnValue = this._tryUnion(returnValue, value, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "getter");
     }
   }
   if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname), node.span);
     }
     else {
       return new Value(returnValue.get$type(), ("" + target.get$code() + ".get$" + this.jsname + "()"), node.span);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
   if (this.members.get$length() == (1) && !this.isVar) {
-    return this.members[(0)]._set$5(context, node, target, value, isDynamic);
+    return this.members.$index((0))._set$5(context, node, target, value, isDynamic);
   }
   var returnValue;
   var targets = this.members.filter$1((function (m) {
     return m.get$canSet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._set$4$isDynamic(context, node, target, value, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span);
   }
   else {
     if (this.members.get$length() == (1)) {
-      return this.members[(0)]._set$5(context, node, target, value, isDynamic);
+      return this.members.$index((0))._set$5(context, node, target, value, isDynamic);
     }
     else if ($eq(targets.get$length(), (1))) {
       return targets.$index((0))._set$5(context, node, target, value, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
       var res = member._set$4$isDynamic(context, node, target, value, true);
       returnValue = this._tryUnion(returnValue, res, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "setter");
     }
   }
   if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname + " = " + value.get$code()), node.span);
     }
     else {
       return new Value(returnValue.get$type(), ("" + target.get$code() + ".set$" + this.jsname + "(" + value.get$code() + ")"), node.span);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.isVar && !this.get$isOperator()) {
     return this.invokeOnVar(context, node, target, args);
   }
   if (this.members.get$length() == (1) && !this.isVar) {
-    return this.members[(0)].invoke$5(context, node, target, args, isDynamic);
+    return this.members.$index((0)).invoke$5(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter$1((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
   if ($eq(targets.get$length(), (1))) {
     return targets.$index((0)).invoke$5(context, node, target, args, isDynamic);
   }
   var returnValue = null;
   if (targets.get$length() < (1000)) {
@@ skipping 114 matching lines @@
 }
 FactoryMap.prototype.addFactory = function(typeName, name, member) {
   this.getFactoriesFor(typeName).$setindex(name, member);
 }
 FactoryMap.prototype.getFactory = function(typeName, name) {
   return this.getFactoriesFor(typeName).$index(name);
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
-      f.call$1(member);
+      f(member);
     })
     );
   })
   );
 }
 FactoryMap.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FactoryMap.prototype.getFactory$2 = FactoryMap.prototype.getFactory;
 // ********** Code for Token **************
@@ skipping 75 matching lines @@
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = (0);
    i < starts.get$length(); i++) {
     if (starts.$index(i) > position) return i - (1);
   }
   $globals.world.internalError("bad position");
 }
 SourceFile.prototype.getColumn = function(line, position) {
-  return position - this.get$lineStarts()[line];
+  return position - this.get$lineStarts().$index(line);
 }
 SourceFile.prototype.getLocationMessage = function(message, start, end, includeText) {
   var line = this.getLine(start);
   var column = this.getColumn(line, start);
   var buf = new StringBufferImpl(("" + this.filename + ":" + ($add(line, (1))) + ":" + ($add(column, (1))) + ": " + message));
   if (includeText) {
     buf.add$1("\n");
     var textLine;
     if (($add(line, (2))) < this._lineStarts.get$length()) {
-      textLine = this.get$text().substring(this._lineStarts[line], this._lineStarts[$add(line, (1))]);
+      textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index($add(line, (1))));
     }
     else {
-      textLine = this.get$text().substring(this._lineStarts[line]) + "\n";
+      textLine = this.get$text().substring(this._lineStarts.$index(line)) + "\n";
     }
     var toColumn = Math.min($add(column, (end - start)), textLine.get$length());
     if ($globals.options.useColors) {
       buf.add$1(textLine.substring$2((0), column));
       buf.add$1($globals._RED_COLOR);
       buf.add$1(textLine.substring$2(column, toColumn));
       buf.add$1($globals._NO_COLOR);
       buf.add$1(textLine.substring$1(toColumn));
     }
     else {
@@ skipping 2963 matching lines @@
   if (this._inhibitLambda) return false;
   var after = this._peekAfterCloseParen();
   return after.kind == (9) || after.kind == (6);
 }
 Parser.prototype._eatLeftParen = function() {
   this._eat((2));
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
   if (this._afterParensIndex < this._afterParens.get$length()) {
-    return this._afterParens[this._afterParensIndex];
+    return this._afterParens.$index(this._afterParensIndex);
   }
   this._afterParensIndex = (0);
   this._afterParens.clear();
   var tokens = [this._lang_next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
   this._lang_next();
   return after;
@@ skipping 450 matching lines @@
 }
 IncompleteSourceException.prototype.toString$0 = IncompleteSourceException.prototype.toString;
 // ********** Code for DivertedTokenSource **************
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
   this.parser = parser;
   this._lang_pos = (0);
   this.tokens = tokens;
   this.previousTokenizer = previousTokenizer;
 }
 DivertedTokenSource.prototype.next = function() {
-  var token = this.tokens[this._lang_pos];
+  var token = this.tokens.$index(this._lang_pos);
   ++this._lang_pos;
   if (this._lang_pos == this.tokens.get$length()) {
     this.parser.tokenizer = this.previousTokenizer;
   }
   return token;
 }
 DivertedTokenSource.prototype.next$0 = DivertedTokenSource.prototype.next;
 // ********** Code for Node **************
 function Node(span) {
   this.span = span;
@@ skipping 916 matching lines @@
       var typeParam = params.next$0();
       var typeArg = args.next$0();
       if (typeParam.get$extendsType() != null && typeArg != null) {
         typeArg.ensureSubtypeOf$3(typeParam.get$extendsType(), typeParam.get$span(), true);
       }
     }
   }
   if (this.get$interfaces() != null) {
     var $$list = this.get$interfaces();
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var i = $$list[$$i];
+      var i = $$list.$index($$i);
       i._checkExtends$0();
     }
   }
 }
 Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if (parentMember != null) {
     if (!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library())) {
       member.override(parentMember);
     }
@@ skipping 18 matching lines @@
       return this.get$parent().getMember(memberName);
     }
     else {
       return null;
     }
   }
   else {
     if (this.get$interfaces() != null && this.get$interfaces().get$length() > (0)) {
       var $$list = this.get$interfaces();
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-        var i = $$list[$$i];
+        var i = $$list.$index($$i);
         var ret = i.getMember$1(memberName);
         if (ret != null) {
           return ret;
         }
       }
     }
     return $globals.world.objectType.getMember(memberName);
   }
 }
 Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
@@ skipping 304 matching lines @@
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.library;
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
-  return this.typeArguments.getValues().some((function (e) {
+  return this.typeArguments.getValues$0().some$1((function (e) {
     return (e instanceof ParameterType);
   })
   );
 }
 ConcreteType.prototype.get$isUsed = function() { return this.isUsed; };
 ConcreteType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 ConcreteType.prototype.get$members = function() { return this.members; };
 ConcreteType.prototype.set$members = function(value) { return this.members = value; };
 ConcreteType.prototype.get$constructors = function() { return this.constructors; };
 ConcreteType.prototype.set$constructors = function(value) { return this.constructors = value; };
 ConcreteType.prototype.get$factories = function() { return this.factories; };
 ConcreteType.prototype.set$factories = function(value) { return this.factories = value; };
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   var newTypeArgs = [];
   var needsNewType = false;
   var $$list = this.typeArgsInOrder;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var t = $$list[$$i];
+    var t = $$list.$index($$i);
     var newType = t.resolveTypeParams$1(inType);
     if ($ne(newType, t)) needsNewType = true;
     newTypeArgs.add$1(newType);
   }
   if (!needsNewType) return this;
   return this.genericType.getOrMakeConcreteType(newTypeArgs);
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
   if (this._parent == null && this.genericType.get$parent() != null) {
     this._parent = this.genericType.get$parent().resolveTypeParams(this);
   }
   return this._parent;
 }
 ConcreteType.prototype.get$interfaces = function() {
   if (this._interfaces == null && this.genericType.interfaces != null) {
     this._interfaces = [];
     var $$list = this.genericType.interfaces;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var i = $$list[$$i];
+      var i = $$list.$index($$i);
       this._interfaces.add(i.resolveTypeParams$1(this));
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.get$subtypes = function() {
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $$list = this.genericType.get$subtypes();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
@@ skipping 200 matching lines @@
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
   this._checkExtends();
   if (this._lazyGenMethods != null) {
     var $$list = orderValuesByKeys(this._lazyGenMethods);
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var method = $$list[$$i];
+      var method = $$list.$index($$i);
       $globals.world.gen.genMethod(method);
     }
     this._lazyGenMethods = null;
   }
   if (this.get$parent() != null) this.get$parent().markUsed();
 }
 DefinedType.prototype.genMethod = function(method) {
   if (this.isUsed) {
     $globals.world.gen.genMethod(method);
   }
   else if (this.isClass) {
     if (this._lazyGenMethods == null) this._lazyGenMethods = new HashMapImplementation();
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
   if (types == null) return [];
   var interfaces = [];
   for (var $$i = 0;$$i < types.get$length(); $$i++) {
-    var type = types[$$i];
+    var type = types.$index($$i);
     var resolvedInterface = this.resolveType$2(type, true);
     if (resolvedInterface.get$isClosed() && !(this.library.get$isCore() || this.library.get$isCoreImpl())) {
       $globals.world.error(("can not implement \"" + resolvedInterface.get$name() + "\": ") + "only native implementation allowed", type.get$span());
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return interfaces;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
@@ skipping 35 matching lines @@
     if (ancestor == null) return false;
     if (ancestor == $this) return true;
     if (seen.contains$1(ancestor)) {
       return false;
     }
     seen.add$1(ancestor);
     if (ancestor.get$interfaces() != null) {
       var $$list = ancestor.get$interfaces();
       for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
         var parent = $$i.next$0();
-        if (_helper.call$1(parent)) return true;
+        if (_helper(parent)) return true;
       }
     }
     return false;
   }
   for (var i = (0);
    i < this.interfaces.get$length(); i++) {
-    if (_helper.call$1(this.interfaces[i])) return i;
+    if (_helper(this.interfaces.$index(i))) return i;
   }
   return (-1);
 }
 DefinedType.prototype.resolve = function() {
   if ((this.definition instanceof TypeDefinition)) {
     var typeDef = this.definition;
     if (this.isClass) {
       if (typeDef.extendsTypes != null && typeDef.extendsTypes.get$length() > (0)) {
         if (typeDef.extendsTypes.get$length() > (1)) {
-          $globals.world.error("more than one base class", typeDef.extendsTypes[(1)].get$span());
+          $globals.world.error("more than one base class", typeDef.extendsTypes.$index((1)).get$span());
         }
-        var extendsTypeRef = typeDef.extendsTypes[(0)];
+        var extendsTypeRef = typeDef.extendsTypes.$index((0));
         if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = extendsTypeRef;
           this.set$parent(this.resolveType$2(g.baseType, true));
         }
         this.set$parent(this.resolveType$2(extendsTypeRef, true));
         if (!this.get$parent().get$isClass()) {
-          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes[(0)].get$span());
+          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes.$index((0)).get$span());
         }
         this.get$parent().addDirectSubtype$1(this);
         if (this._cycleInClassExtends()) {
           $globals.world.error(("class \"" + this.name + "\" has a cycle in its inheritance chain"), extendsTypeRef.get$span());
         }
       }
       else {
         if (!this.get$isObject()) {
           this.set$parent($globals.world.objectType);
           this.get$parent().addDirectSubtype$1(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if (typeDef.defaultType != null) {
         $globals.world.error("default not allowed on classes", typeDef.defaultType.span);
       }
     }
     else {
       if (typeDef.implementsTypes != null && typeDef.implementsTypes.get$length() > (0)) {
-        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes[(0)].get$span());
+        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes.$index((0)).get$span());
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
       if (res >= (0)) {
-        $globals.world.error(("interface \"" + this.name + "\" has a cycle in its inheritance chain"), typeDef.extendsTypes[res].get$span());
+        $globals.world.error(("interface \"" + this.name + "\" has a cycle in its inheritance chain"), typeDef.extendsTypes.$index(res).get$span());
       }
       if (typeDef.defaultType != null) {
         this.defaultType = this.resolveType$2(typeDef.defaultType.baseType, true);
         if (this.defaultType == null) {
           $globals.world.warning("unresolved default class", typeDef.defaultType.span);
         }
         else {
           this.defaultType._resolveTypeParams(typeDef.defaultType.typeParameters);
         }
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [$globals.world.functionType];
   }
   this._resolveTypeParams(this.typeParameters);
   if (this.get$isObject()) this._createNotEqualMember();
   $globals.world._addType(this);
-  var $$list = this.constructors.getValues();
+  var $$list = this.constructors.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var c = $$i.next$0();
     c.resolve$0();
   }
-  var $$list = this.members.getValues();
+  var $$list = this.members.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var m = $$i.next$0();
     m.resolve$0();
   }
   this.factories.forEach((function (f) {
     return f.resolve$0();
   })
   );
   if (this.get$isJsGlobalObject()) {
-    var $$list = this.members.getValues();
+    var $$list = this.members.getValues$0();
     for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
       var m = $$i.next$0();
       if (!m.get$isStatic()) $globals.world._addTopName(new ExistingJsGlobal(m.get$name(), m));
     }
   }
 }
 DefinedType.prototype._resolveTypeParams = function(params) {
   if (params == null) return;
   for (var $$i = 0;$$i < params.get$length(); $$i++) {
-    var tp = params[$$i];
+    var tp = params.$index($$i);
     tp.set$enclosingElement(this);
     tp.resolve$0();
   }
 }
 DefinedType.prototype.addMethod = function(methodName, definition) {
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(("duplicate constructor definition of " + method.get$name()), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition.modifiers != null && definition.modifiers.get$length() == (1) && $eq(definition.modifiers[(0)].get$kind(), (74))) {
+  if (definition.modifiers != null && definition.modifiers.get$length() == (1) && $eq(definition.modifiers.$index((0)).get$kind(), (74))) {
     if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
       $globals.world.error(("duplicate factory definition of \"" + method.get$name() + "\""), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
     return;
   }
   if (methodName.startsWith("get:") || methodName.startsWith("set:")) {
     var propName = methodName.substring((4));
     var prop = this.members.$index(propName);
@@ skipping 21 matching lines @@
   }
   if (this.members.containsKey(methodName)) {
     $globals.world.error(("duplicate method definition of \"" + method.get$name() + "\""), definition.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition) {
   for (var i = (0);
    i < definition.names.get$length(); i++) {
-    var name = definition.names[i].get$name();
+    var name = definition.names.$index(i).get$name();
     if (this.members.containsKey(name)) {
       $globals.world.error(("duplicate field definition of \"" + name + "\""), definition.span);
       return;
     }
     var value = null;
     if (definition.values != null) {
-      value = definition.values[i];
+      value = definition.values.$index(i);
     }
     var field = new FieldMember(name, this, definition, value);
     this.members.$setindex(name, field);
     if (this.isNative) {
       field.set$isNative(true);
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
@@ skipping 18 matching lines @@
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._checkDefaultTypeParams = function() {
   function toList(list) {
     return (list != null ? list : const$0008);
   }
   var typeDef = this.definition;
   if (typeDef.defaultType.oldFactory) {
     return;
   }
-  var interfaceParams = toList.call$1(this.typeParameters);
-  var defaultParams = toList.call$1(typeDef.defaultType.typeParameters);
-  var classParams = toList.call$1(this.defaultType.typeParameters);
+  var interfaceParams = toList(this.typeParameters);
+  var defaultParams = toList(typeDef.defaultType.typeParameters);
+  var classParams = toList(this.defaultType.typeParameters);
   if ($ne(interfaceParams.get$length(), defaultParams.get$length()) || $ne(defaultParams.get$length(), classParams.get$length())) {
     $globals.world.error("\"default\" must have the same number of type parameters as the class and interface do", this.get$span(), typeDef.defaultType.span, this.defaultType.get$span());
     return;
   }
   for (var i = (0);
    i < interfaceParams.get$length(); i++) {
     var ip = interfaceParams.$index(i);
     var dp = defaultParams.$index(i);
     var cp = classParams.$index(i);
     dp.resolve$0();
@@ skipping 51 matching lines @@
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
   var jsnames = [];
   var names = [];
   var typeMap = new HashMapImplementation();
   for (var i = (0);
    i < typeArgs.get$length(); i++) {
-    var paramName = this.typeParameters[i].get$name();
-    typeMap.$setindex(paramName, typeArgs[i]);
-    names.add$1(typeArgs[i].get$name());
-    jsnames.add$1(typeArgs[i].get$jsname());
+    var paramName = this.typeParameters.$index(i).get$name();
+    typeMap.$setindex(paramName, typeArgs.$index(i));
+    names.add$1(typeArgs.$index(i).get$name());
+    jsnames.add$1(typeArgs.$index(i).get$jsname());
   }
   var jsname = ("" + this.get$jsname() + "_" + Strings.join(jsnames, "$"));
   var simpleName = ("" + this.name + "<" + Strings.join(names, ", ") + ">");
   var key = Strings.join(names, "$");
   var ret = this._concreteTypes.$index(key);
   if (ret == null) {
     ret = new ConcreteType(simpleName, this, typeMap, typeArgs);
     ret.set$_jsname(jsname);
     this._concreteTypes.$setindex(key, ret);
   }
@@ skipping 62 matching lines @@
 }
 FixedCollection.prototype.every = function(f) {
   return Collections.every(this, f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == (0);
 }
+FixedCollection.prototype.every$1 = function($0) {
+  return this.every(to$call$1($0));
+};
 FixedCollection.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 FixedCollection.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FixedCollection.prototype.isEmpty$0 = FixedCollection.prototype.isEmpty;
 FixedCollection.prototype.iterator$0 = FixedCollection.prototype.iterator;
+FixedCollection.prototype.some$1 = function($0) {
+  return this.some(to$call$1($0));
+};
 // ********** Code for FixedCollection_Type **************
 $inherits(FixedCollection_Type, FixedCollection);
 function FixedCollection_Type(value, length) {
   this.value = value;
   this.length = length;
 }
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this.length = length;
   this._index = (0);
@@ skipping 501 matching lines @@
       $globals.world.gen.corejs.useThrow = true;
       return ("$throw(" + result.get$code() + ")");
     })
     );
   }
   if (toType.get$isNum()) toType = $globals.world.numType;
   var check;
   if (toType.get$isVoid()) {
     check = ("$assert_void(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
-      toType.typeCheckCode = ("function $assert_void(x) {\n  if (x == null) return null;\n  " + throwTypeError.call$1("x") + "\n}");
+      toType.typeCheckCode = ("function $assert_void(x) {\n  if (x == null) return null;\n  " + throwTypeError("x") + "\n}");
     }
   }
   else if ($eq(toType, $globals.world.nonNullBool)) {
     $globals.world.gen.corejs.useNotNullBool = true;
     check = ("$notnull_bool(" + this.get$code() + ")");
   }
   else if (toType.get$library().get$isCore() && toType.get$typeofName() != null) {
     check = ("$assert_" + toType.name + "(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
-      toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  " + throwTypeError.call$1("x") + "\n}");
+      toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  " + throwTypeError("x") + "\n}");
     }
   }
   else {
     toType.isChecked = true;
     var checkName = "assert$" + toType.get$jsname();
     var temp = context.getTemp(this);
     check = ("(" + context.assignTemp(temp, this).get$code() + " == null ? null :");
     check = check + (" " + temp.get$code() + "." + checkName + "())");
     if ($ne(this, temp)) context.freeTemp(temp);
     $globals.world.objectType.varStubs.putIfAbsent(checkName, (function () {
-      return new VarMethodStub(checkName, null, Arguments.get$EMPTY(), throwTypeError.call$1("this"));
+      return new VarMethodStub(checkName, null, Arguments.get$EMPTY(), throwTypeError("this"));
     })
     );
   }
   context.counters.typeAsserts++;
   return new Value(toType, check, this.span);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if (toType.get$isVar()) {
     $globals.world.error("can not resolve type", span);
   }
@@ skipping 43 matching lines @@
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   if (this.get$isType()) {
     $globals.world.error(("member lookup failed for \"" + name + "\""), node.span);
   }
   var pos = "";
   if (args != null) {
     var argsCode = [];
     for (var i = (0);
      i < args.get$length(); i++) {
-      argsCode.add$1(args.values[i].get$code());
+      argsCode.add$1(args.values.$index(i).get$code());
     }
     pos = Strings.join(argsCode, ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ("\"" + name + "\""), node.span), new Value($globals.world.listType, ("[" + pos + "]"), node.span)];
   return this._resolveMember(context, "noSuchMethod", node, false).invoke(context, node, this, new Arguments(null, noSuchArgs), false);
 }
 Value.fromBool = function(value, span) {
   return new BoolValue(value, true, span);
 }
 Value.fromInt = function(value, span) {
@@ skipping 553 matching lines @@
 function ListValue(values, isConst, type, span) {
   this.values = values;
   EvaluatedValue.call(this, isConst, type, span);
 }
 ListValue.prototype.get$code = function() {
   var buf = new StringBufferImpl("");
   buf.add$1("[");
   for (var i = (0);
    i < this.values.get$length(); i = $add(i, (1))) {
     if (i > (0)) buf.add$1(", ");
-    buf.add$1(this.values[i].get$code());
+    buf.add$1(this.values.$index(i).get$code());
   }
   buf.add$1("]");
   var listCode = buf.toString$0();
   if (!this.isConst) return listCode;
   var v = new Value($globals.world.listType, listCode, this.span);
   var immutableListCtor = $globals.world.immutableListType.getConstructor("from");
   var result = immutableListCtor.invoke$4(null, null, new TypeValue(v.get$type(), this.span), new Arguments(null, [v]));
   return result.get$code();
 }
 ListValue.prototype.binop = function(kind, other, context, node) {
@@ skipping 91 matching lines @@
     else {
       this.fields.$setindex(field, value);
     }
   }
 }
 ObjectValue.prototype.validateInitialized = function(span) {
   var buf = new StringBufferImpl("");
   buf.add$1("Object.create(");
   buf.add$1(("" + this.get$type().get$jsname() + ".prototype, "));
   buf.add$1("{");
-  var $$list = this.fields.getKeys();
+  var $$list = this.fields.getKeys$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var field = $$i.next$0();
     buf.add$1(field.get$name());
     buf.add$1(": ");
     buf.add$1("{\"value\": ");
     if (this.fields.$index(field) == null) {
       $globals.world.error(("Required field \"" + field.get$name() + "\" was not initialized"), span, field.get$span());
       buf.add$1("null");
     }
     else {
@@ skipping 25 matching lines @@
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
 function GlobalValue(type, code, isConst, field, name, exp, span, deps) {
   this.exp = exp;
   this.field = field;
   this.name = name;
   this.dependencies = [];
   this.isConst = isConst;
   Value.call(this, type, code, span);
   for (var $$i = 0;$$i < deps.get$length(); $$i++) {
-    var dep = deps[$$i];
+    var dep = deps.$index($$i);
     if ((dep instanceof GlobalValue)) {
       this.dependencies.add(dep);
       this.dependencies.addAll(dep.get$dependencies());
     }
   }
 }
 GlobalValue.prototype.get$field = function() { return this.field; };
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.get$exp = function() { return this.exp; };
 GlobalValue.prototype.get$isConst = function() { return this.isConst; };
@@ skipping 378 matching lines @@
   this.printStatus();
   return !this.get$hasErrors();
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if (!$globals.options.enableLeg) return false;
   if ($globals.legCompile == null) {
     this.fatal("requested leg enabled, but no leg compiler available");
   }
   var res = this.withTiming("try leg compile", (function () {
-    return $globals.legCompile.call$1($this);
+    return $globals.legCompile($this);
   })
   );
   if (!res && $globals.options.legOnly) {
     this.fatal(("Leg could not compile " + $globals.options.dartScript));
     return true;
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
@@ skipping 58 matching lines @@
     }
   }
 }
 World.prototype.processDartScript = function(script) {
   if (script == null) script = $globals.options.dartScript;
   var library = this.getOrAddLibrary(script);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
-  var $$list = this.libraries.getValues();
+  var $$list = this.libraries.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.resolve$0();
   }
-  var $$list = this.libraries.getValues();
+  var $$list = this.libraries.getValues$0();
   for (var $$i = $$list.iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.postResolveChecks$0();
   }
 }
 World.prototype.get$resolveAll = function() {
   return this.resolveAll.bind(this);
 }
 World.prototype.findMainMethod = function(lib) {
   var main = lib.lookup("main", lib.get$span());
@@ skipping 129 matching lines @@
   else {
     $globals.world.error(("Invalid configuration " + this.config));
     $throw("Invalid configuration");
   }
   var ignoreUnrecognizedFlags = false;
   var passedLibDir = false;
   this.childArgs = [];
   loop:
   for (var i = (2);
    i < args.get$length(); i++) {
-    var arg = args[i];
+    var arg = args.$index(i);
     switch (arg) {
       case "--enable_leg":
 
         this.enableLeg = true;
         break;
 
       case "--leg_only":
 
         this.enableLeg = true;
         this.legOnly = true;
@@ skipping 72 matching lines @@
 
       case "--Xinfer_types":
 
         this.inferTypes = true;
         break;
 
       default:
 
         if (arg.endsWith$1(".dart")) {
           this.dartScript = arg;
-          this.childArgs = args.getRange(i + (1), args.get$length() - i - (1));
+          this.childArgs = args.getRange$2(i + (1), args.get$length() - i - (1));
           break loop;
         }
         else if (arg.startsWith$1("--out=")) {
           this.outfile = arg.substring$1("--out=".length);
         }
         else if (arg.startsWith$1("--libdir=")) {
           this.libDir = arg.substring$1("--libdir=".length);
           passedLibDir = true;
         }
         else {
@@ skipping 151 matching lines @@
   ).get$length() >= (1);
 }
 VarMethodStub.prototype._useDirectCall = function(args) {
   if ((this.member instanceof MethodMember) && !this.member.declaringType.get$hasNativeSubtypes()) {
     var method = this.member;
     if (method.needsArgumentConversion(args)) {
       return false;
     }
     for (var i = args.get$length();
      i < method.parameters.get$length(); i++) {
-      if ($ne(method.parameters[i].get$value().get$code(), "null")) {
+      if ($ne(method.parameters.$index(i).get$value().get$code(), "null")) {
         return false;
       }
     }
     return method.namesInHomePositions(args);
   }
   else {
     return false;
   }
 }
 VarMethodStub.prototype.generate$1 = VarMethodStub.prototype.generate;
@@ skipping 12 matching lines @@
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if (this.invoked) return;
   this.invoked = true;
   var hasObjectType = false;
   var $$list = this.members;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var member = $$list[$$i];
+    var member = $$list.$index($$i);
     var type = member.get$declaringType();
     var target = new Value(type, "this", node.span);
     var result = member.invoke$4$isDynamic(context, node, target, this.args, true);
     var stub = new VarMethodStub(this.name, member, this.args, "return " + result.get$code());
     type.get$varStubs().$setindex(stub.get$name(), stub);
     if (type.get$isObject()) hasObjectType = true;
   }
   if (!hasObjectType) {
     var target = new Value($globals.world.objectType, "this", node.span);
     var result = target.invokeNoSuchMethod$4(context, this.baseName, node, this.args);
@@ skipping 10 matching lines @@
 function _otherOperator(jsname, op) {
   return ("function " + jsname + "(x, y) {\n  return (typeof(x) == 'number' && typeof(y) == 'number')\n    ? x " + op + " y : x." + jsname + "(y);\n}");
 }
 function map(source, mapper) {
   var result = new Array();
   if (!!(source && source.is$List())) {
     var list = source;
     result.set$length(list.get$length());
     for (var i = (0);
      i < list.get$length(); i++) {
-      result.$setindex(i, mapper.call$1(list[i]));
+      result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
     for (var $$i = source.iterator$0(); $$i.hasNext$0(); ) {
       var item = $$i.next$0();
-      result.add(mapper.call$1(item));
+      result.add(mapper(item));
     }
   }
   return result;
 }
 function reduce(source, callback, initialValue) {
   var i = source.iterator$0();
   var current = initialValue;
   if (current == null && i.hasNext$0()) {
     current = i.next$0();
   }
   while (i.hasNext$0()) {
     current = callback.call$2(current, i.next$0());
   }
   return current;
 }
 function orderValuesByKeys(map) {
-  var keys = map.getKeys();
+  var keys = map.getKeys$0();
   keys.sort((function (x, y) {
     return x.compareTo$1(y);
   })
   );
   var values = [];
   for (var $$i = 0;$$i < keys.get$length(); $$i++) {
-    var k = keys[$$i];
+    var k = keys.$index($$i);
     values.add$1(map.$index(k));
   }
   return values;
 }
 var world;
 var experimentalAwaitPhase;
 var legCompile;
 function initializeWorld(files) {
   $globals.world = new World(files);
   $globals.world.init();
@@ skipping 16 matching lines @@
     if (name0.contains$1("$")) {
       nameBuilder.add$1(("" + name0.get$length()));
     }
     nameBuilder.add$1(name0);
   }
   return nameBuilder.toString$0();
 }
 //  ********** Library minfrog **************
 // ********** Code for top level **************
 function main() {
-  var homedir = path.dirname(fs.realpathSync(get$process().get$argv()[(1)]));
+  var homedir = path.dirname(get$fs().realpathSync(get$process().get$argv().$index((1))));
   var argv = [];
   for (var i = (0);
    i < get$process().get$argv().get$length(); i++) {
-    argv.add$1(get$process().get$argv()[i]);
+    argv.add$1(get$process().get$argv().$index(i));
     if (i == (1)) {
       var terminal = get$process().get$env().$index("TERM");
       if (terminal == null || !terminal.startsWith$1("xterm")) {
         argv.add$1("--no_colors");
       }
     }
   }
   if (compile(homedir, argv, new NodeFileSystem())) {
     var code = $globals.world.getGeneratedCode();
     if ($globals.options.compileOnly) {
@@ skipping 18 matching lines @@
 /** Implements extends for generic types. */
 function $inheritsMembers(child, parent) {
   child = child.prototype;
   parent = parent.prototype;
   Object.getOwnPropertyNames(parent).forEach(function(name) {
     if (typeof(child[name]) == 'undefined') child[name] = parent[name];
   });
 }
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_E, DoubleLinkedQueueEntry_E);
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
+$inheritsMembers(NativeMapPrimitiveValue_dart_core_String, NativeMapBase_dart_core_String);
 $inheritsMembers(_SharedBackingMap_K$V, HashMapImplementation_K$V);
 $inheritsMembers(_SharedBackingMap_dart_core_String$VariableValue, HashMapImplementation_dart_core_String$VariableValue);
 // 1 dynamic types.
 // 1 types
 // 0 !leaf
 //  ********** Globals **************
 function $static_init(){
   $globals._GREEN_COLOR = "\x1b[32m";
   $globals._MAGENTA_COLOR = "\x1b[35m";
   $globals._NO_COLOR = "\x1b[0m";
   $globals._RED_COLOR = "\x1b[31m";
 }
 var const$0000 = Object.create(EmptyQueueException.prototype, {});
 var const$0001 = Object.create(_DeletedKeySentinel.prototype, {});
 var const$0005 = Object.create(NoMoreElementsException.prototype, {});
 var const$0007 = Object.create(IllegalAccessException.prototype, {});
 var const$0008 = ImmutableList.ImmutableList$from$factory([]);
 var $globals = {};
 $static_init();
 main();