frog: better binding of methods.

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 389 matching lines @@
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments) {
   this._receiver = _receiver;
   this._functionName = _functionName;
   this._arguments = _arguments;
   // Initializers done
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = 0;
-   i < this._arguments.length; i++) {
+   i < this._arguments.get$length(); i++) {
     if (i > 0) {
       sb.add(", ");
     }
     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 ObjectNotClosureException **************
@@ skipping 104 matching lines @@
     if (obj) obj = obj.toString();
     console.log(obj);
   } else {
     write(obj);
     write('\n');
   }
 }
 function _map(itemsAndKeys) {
   var ret = new LinkedHashMapImplementation();
   for (var i = 0;
-   i < itemsAndKeys.length; ) {
+   i < itemsAndKeys.get$length(); ) {
     ret.$setindex(itemsAndKeys.$index(i++), itemsAndKeys.$index(i++));
   }
   return ret;
 }
 function _toDartException(e) {
   function attachStack(dartEx) {
     // TODO(jmesserly): setting the stack property is not a long term solution.
     var stack = e.stack;
     // The stack contains the error message, and the stack is all that is
     // printed (the exception's toString() is never called).  Make the Dart
@@ skipping 48 matching lines @@
 ListFactory = Array;
 ListFactory.prototype.is$List = function(){return true};
 ListFactory.ListFactory$from$factory = function(other) {
   var list = [];
   for (var $$i = other.iterator(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     list.add(e);
   }
   return list;
 }
+ListFactory.prototype.get$length = function() { return this.length; };
+ListFactory.prototype.set$length = function(value) { return this.length = value; };
 ListFactory.prototype.add = function(value) {
   this.push(value);
 }
 ListFactory.prototype.addLast = function(value) {
   this.push(value);
 }
 ListFactory.prototype.addAll = function(collection) {
   for (var $$i = collection.iterator(); $$i.hasNext$0(); ) {
     var item = $$i.next$0();
     this.add(item);
   }
 }
 ListFactory.prototype.clear = function() {
-  this.length = 0;
+  this.set$length(0);
 }
 ListFactory.prototype.removeLast = function() {
   return this.pop();
 }
 ListFactory.prototype.last = function() {
-  return this[this.length - 1];
+  return this[this.get$length() - 1];
 }
 ListFactory.prototype.getRange = function(start, length) {
   return this.slice(start, start + length);
 }
 ListFactory.prototype.isEmpty = function() {
-  return this.length == 0;
+  return this.get$length() == 0;
 }
 ListFactory.prototype.iterator = function() {
   return new ListIterator(this);
 }
 ListFactory.prototype.add$1 = ListFactory.prototype.add;
 ListFactory.prototype.addAll$1 = ListFactory.prototype.addAll;
 ListFactory.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 ListFactory.prototype.filter$1 = function($0) {
@@ skipping 17 matching lines @@
 ListFactory_K = ListFactory;
 ListFactory_String = ListFactory;
 ListFactory_V = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._dart_coreimpl_pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
-  return this._array.length > this._dart_coreimpl_pos;
+  return this._array.get$length() > this._dart_coreimpl_pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._dart_coreimpl_pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for NumImplementation **************
@@ skipping 70 matching lines @@
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 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.length);
+  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.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (const$3/*HashMapImplementation._DELETED_KEY*/ === existingKey)) {
       insertionIndex = hash;
     }
-    hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
+    hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
-  var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.length);
+  var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) return -1;
     if ($eq(existingKey, key)) return hash;
-    hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
+    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.length * 2);
+    this._grow(this._keys.get$length() * 2);
     return;
   }
-  var capacity = this._keys.length;
+  var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
-    this._grow(this._keys.length);
+    this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
-  var capacity = this._keys.length;
+  var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory(newCapacity);
   for (var i = 0;
    i < capacity; i++) {
     var key = oldKeys.$index(i);
     if (key == null || key === const$3/*HashMapImplementation._DELETED_KEY*/) {
       continue;
@@ skipping 30 matching lines @@
     return value;
   }
   return null;
 }
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
-Object.defineProperty(HashMapImplementation.prototype, "length", {
-  get: HashMapImplementation.prototype.get$length
-});
 HashMapImplementation.prototype.forEach = function(f) {
-  var length = this._keys.length;
+  var length = this._keys.get$length();
   for (var i = 0;
    i < length; i++) {
     if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== const$3/*HashMapImplementation._DELETED_KEY*/)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory(this.get$length());
   var i = 0;
@@ skipping 46 matching lines @@
 HashMapImplementation_E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation_E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 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.length);
+  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.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (const$3/*HashMapImplementation._DELETED_KEY*/ === existingKey)) {
       insertionIndex = hash;
     }
-    hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
+    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.length);
+  var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) return -1;
     if ($eq(existingKey, key)) return hash;
-    hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
+    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.length * 2);
+    this._grow(this._keys.get$length() * 2);
     return;
   }
-  var capacity = this._keys.length;
+  var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
-    this._grow(this._keys.length);
+    this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation_E$E._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation_E$E.prototype._grow = function(newCapacity) {
-  var capacity = this._keys.length;
+  var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory(newCapacity);
   for (var i = 0;
    i < capacity; i++) {
     var key = oldKeys.$index(i);
     if (key == null || key === const$3/*HashMapImplementation._DELETED_KEY*/) {
       continue;
@@ skipping 23 matching lines @@
     this._keys.$setindex(index, const$3/*HashMapImplementation._DELETED_KEY*/);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation_E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation_E$E.prototype.forEach = function(f) {
-  var length = this._keys.length;
+  var length = this._keys.get$length();
   for (var i = 0;
    i < length; i++) {
     if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== const$3/*HashMapImplementation._DELETED_KEY*/)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation_E$E.prototype.getKeys = function() {
   var list = new ListFactory(this.get$length());
   var i = 0;
@@ skipping 64 matching lines @@
 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();
 }
-Object.defineProperty(HashSetImplementation.prototype, "length", {
-  get: HashSetImplementation.prototype.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) {
@@ skipping 20 matching lines @@
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
-  if (this._nextValidIndex >= this._entries.length) return false;
+  if (this._nextValidIndex >= this._entries.get$length()) return false;
   if (this._entries.$index(this._nextValidIndex) === const$3/*HashMapImplementation._DELETED_KEY*/) {
     this._advance();
   }
-  return this._nextValidIndex < this._entries.length;
+  return this._nextValidIndex < this._entries.get$length();
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
-  var length = this._entries.length;
+  var length = this._entries.get$length();
   var entry;
   var deletedKey = const$3/*HashMapImplementation._DELETED_KEY*/;
   do {
     if (++this._nextValidIndex >= length) break;
     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;
   // Initializers done
   this._advance();
 }
 HashSetIterator_E.prototype._advance = function() {
-  var length = this._entries.length;
+  var length = this._entries.get$length();
   var entry;
   var deletedKey = const$3/*HashMapImplementation._DELETED_KEY*/;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
@@ skipping 57 matching lines @@
     f(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.get$length();
 }
-Object.defineProperty(LinkedHashMapImplementation.prototype, "length", {
-  get: LinkedHashMapImplementation.prototype.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;
 LinkedHashMapImplementation.prototype.isEmpty$0 = LinkedHashMapImplementation.prototype.isEmpty;
@@ skipping 144 matching lines @@
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue.prototype.get$length = function() {
   var counter = 0;
   this.forEach(function _(element) {
     counter++;
   }
   );
   return counter;
 }
-Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
-  get: DoubleLinkedQueue.prototype.get$length
-});
 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(entry._element);
     entry = nextEntry;
   }
@@ skipping 106 matching lines @@
     this._start = Clock.now();
   }
   else {
     if (this._stop == null) {
       return;
     }
     this._start = Clock.now() - (this._stop - this._start);
   }
 }
 StopwatchImplementation.prototype.get$start = function() {
-  return StopwatchImplementation.prototype.start.bind(this);
+  return StopwatchImplementation.prototype.start.bind(this)
 }
 StopwatchImplementation.prototype.stop = function() {
   if (this._start == null) {
     return;
   }
   this._stop = Clock.now();
 }
 StopwatchImplementation.prototype.elapsed = function() {
   if (this._start == null) {
     return 0;
   }
   return (this._stop == null) ? (Clock.now() - this._start) : (this._stop - this._start);
 }
 StopwatchImplementation.prototype.elapsedInMs = function() {
   return $truncdiv((this.elapsed() * 1000), this.frequency());
 }
 StopwatchImplementation.prototype.frequency = function() {
   return Clock.frequency();
 }
 StopwatchImplementation.prototype.start$0 = StopwatchImplementation.prototype.start;
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
   // Initializers done
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
-Object.defineProperty(StringBufferImpl.prototype, "length", {
-  get: StringBufferImpl.prototype.get$length
-});
 StringBufferImpl.prototype.isEmpty = function() {
   return this._length == 0;
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString();
   if (str == null || str.isEmpty()) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $$i = objects.iterator(); $$i.hasNext$0(); ) {
     var obj = $$i.next$0();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new ListFactory();
   this._length = 0;
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
-  if (this._buffer.length == 0) return "";
-  if (this._buffer.length == 1) return this._buffer.$index(0);
+  if (this._buffer.get$length() == 0) return "";
+  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.join = function(strings, separator) {
-  if (strings.length == 0) return '';
+  if (strings.get$length() == 0) return '';
   var s = strings.$index(0);
   for (var i = 1;
-   i < strings.length; i++) {
+   i < strings.get$length(); 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) {
   if (other.length > this.length) return false;
     return other == this.substring(this.length - other.length);
 }
 StringImplementation.prototype.startsWith = function(other) {
   if (other.length > this.length) return false;
     return other == this.substring(0, other.length);
 }
 StringImplementation.prototype.isEmpty = function() {
   return this.length == 0;
@@ skipping 104 matching lines @@
 // ********** Code for top level **************
 function createSandbox() {
   return {'require': require, 'process': process, 'console': console,
         'setTimeout': setTimeout, 'clearTimeout': clearTimeout};
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split('/');
   var $$list = path2.split('/');
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var piece = $$list.$index($$i);
-    if ($eq(piece, '..') && pieces.length > 0 && $ne(pieces.last$0(), '.') && $ne(pieces.last$0(), '..')) {
+    if ($eq(piece, '..') && pieces.get$length() > 0 && $ne(pieces.last$0(), '.') && $ne(pieces.last$0(), '..')) {
       pieces.removeLast$0();
     }
     else if ($ne(piece, '')) {
-      if (pieces.length > 0 && $eq(pieces.last$0(), '.')) {
+      if (pieces.get$length() > 0 && $eq(pieces.last$0(), '.')) {
         pieces.removeLast$0();
       }
       pieces.add$1(piece);
     }
   }
   return Strings.join(pieces, '/');
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
   if (lastSlash == -1) {
@@ skipping 50 matching lines @@
   if (this.writeComments) {
     this.writeln(text);
   }
 }
 CodeWriter.prototype.write = function(text) {
   if (text.length == 0) return;
   if (this._pendingIndent) this._indent();
   if (text.indexOf('\n') != -1) {
     var lines = text.split('\n');
     for (var i = 0;
-     i < lines.length - 1; i++) {
+     i < lines.get$length() - 1; i++) {
       this.writeln(lines.$index(i));
     }
-    this.write(lines.$index(lines.length - 1));
+    this.write(lines.$index(lines.get$length() - 1));
   }
   else {
     this._buf.add(text);
   }
 }
 CodeWriter.prototype.writeln = function(text) {
   if (text != null) {
     this.write(text);
   }
   if (!text.endsWith('\n')) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
@@ skipping 135 matching lines @@
   }
   else {
     if (this.useWrap0) {
       w.writeln("function $wrap_call$0(fn) { return fn; }"/*null._EMPTY_WRAP_CALL0_FUNCTION*/);
     }
     if (this.useWrap1) {
       w.writeln("function $wrap_call$1(fn) { return fn; }"/*null._EMPTY_WRAP_CALL1_FUNCTION*/);
     }
   }
   var $$list = orderValuesByKeys(this._usedOperators);
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var opImpl = $$list.$index($$i);
     w.writeln(opImpl);
   }
 }
 CoreJs.prototype.generate$1 = CoreJs.prototype.generate;
 // ********** Code for Element **************
 function Element(name, _enclosingElement) {
   this.name = name;
   this._enclosingElement = _enclosingElement;
   // Initializers done
@@ skipping 37 matching lines @@
     var typeRef = node;
     var name;
     if (typeRef.names != null) {
       name = typeRef.names.last().get$name();
     }
     else {
       name = typeRef.name.name;
     }
     if (this.get$typeParameters() != null) {
       var $$list = this.get$typeParameters();
-      for (var $$i = 0;$$i < $$list.length; $$i++) {
+      for (var $$i = 0;$$i < $$list.get$length(); $$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(node, typeErrors);
   }
   else if ((node instanceof GenericTypeReference)) {
     var typeRef = node;
     var baseType = this.resolveType(typeRef.baseType, typeErrors);
     if (!baseType.get$isGeneric()) {
       $globals.world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
       return null;
     }
-    if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
+    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.length; i++) {
+     i < typeRef.typeArguments.get$length(); i++) {
       typeArgs.add$1(this.resolveType(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;
     }
@@ skipping 21 matching lines @@
   var mainCall = this.main.invoke(metaGen, null, mainTarget, Arguments.get$EMPTY(), false);
   this.main.declaringType.markUsed();
   if ($globals.options.compileAll) {
     this.markLibrariesUsed([$globals.world.get$coreimpl(), $globals.world.corelib, this.main.declaringType.get$library()]);
   }
   else {
     $globals.world.corelib.types.$index('BadNumberFormatException').markUsed$0();
     $globals.world.get$coreimpl().types.$index('NumImplementation').markUsed$0();
     $globals.world.get$coreimpl().types.$index('StringImplementation').markUsed$0();
     this.genMethod($globals.world.get$coreimpl().types.$index('StringImplementation').getMember$1('contains'));
+    if ($globals.world.corelib.types.$index('String').get$isUsed()) {
+      $globals.world.get$coreimpl().types.$index('ListFactory').markUsed$0();
+    }
   }
   if ($globals.world.corelib.types.$index('Isolate').get$isUsed() || $globals.world.get$coreimpl().types.$index('ReceivePortImpl').get$isUsed()) {
     if (this.corejs.useWrap0 || this.corejs.useWrap1) {
       this.genMethod($globals.world.get$coreimpl().types.$index('IsolateContext').getMember$1('eval'));
       this.genMethod($globals.world.get$coreimpl().types.$index('EventLoop').getMember$1('run'));
     }
     this.corejs.useIsolates = true;
     var isolateMain = $globals.world.get$coreimpl().topType.resolveMember('startRootIsolate').members.$index(0);
     var isolateMainTarget = new Value.type$ctor($globals.world.get$coreimpl().topType, this.main.get$span());
     mainCall = isolateMain.invoke(metaGen, null, isolateMainTarget, new Arguments(null, [this.main._get(metaGen, this.main.definition, null, false)]), false);
@@ skipping 15 matching lines @@
   type.isTested = !type.get$isTop() && !(type.get$isNative() && type.get$members().getValues().every$1((function (m) {
     return m.get$isStatic() && !m.get$isFactory();
   })
   ));
   var members = ListFactory.ListFactory$from$factory(type.get$members().getValues());
   members.addAll(type.get$constructors().getValues());
   type.get$factories().forEach((function (f) {
     return members.add(f);
   })
   );
-  for (var $$i = 0;$$i < members.length; $$i++) {
+  for (var $$i = 0;$$i < members.get$length(); $$i++) {
     var member = members.$index($$i);
     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 WorldGenerator.prototype.markTypeUsed.bind(this);
+  return WorldGenerator.prototype.markTypeUsed.bind(this)
 }
 WorldGenerator.prototype.getAllTypes = function(libs) {
   var types = [];
   var seen = new HashSetImplementation();
-  for (var $$i = 0;$$i < libs.length; $$i++) {
+  for (var $$i = 0;$$i < libs.get$length(); $$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)
       );
@@ skipping 17 matching lines @@
   var key = exp.get$type().get$jsname() + ':' + exp.canonicalCode;
   if (!this.globals.containsKey(key)) {
     this.globals.$setindex(key, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
   return this.globals.$index(key);
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if (lib.isWritten) return;
   lib.isWritten = true;
   var $$list = lib.imports;
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var import_ = $$list.$index($$i);
     this.writeTypes(import_.get$library());
   }
   for (var i = 0;
-   i < lib.sources.length; i++) {
+   i < lib.sources.get$length(); 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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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 $$list = this._orderValues(lib.types);
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var type = $$list.$index($$i);
     if ((type.get$isUsed() || $eq(type.get$library(), $globals.world.get$dom()) || type.get$isHiddenNativeType()) && type.get$isClass()) {
       this.writeType(type);
       if (type.get$isGeneric()) {
         var $list0 = this._orderValues(type.get$_concreteTypes());
-        for (var $i0 = 0;$i0 < $list0.length; $i0++) {
+        for (var $i0 = 0;$i0 < $list0.get$length(); $i0++) {
           var ct = $list0.$index($i0);
           this.writeType(ct);
         }
       }
     }
-    else if (type.get$isFunction() && type.get$varStubs().length > 0) {
+    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());
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
   if (!meth.isGenerated && !meth.get$isAbstract() && meth.get$definition() != null) {
     new MethodGenerator(meth, enclosingMethod).run();
   }
 }
 WorldGenerator.prototype._prototypeOf = function(type, name) {
   if (type.get$isSingletonNative()) {
     return ('' + type.get$jsname() + '.' + name);
   }
   else if (type.get$isHiddenNativeType()) {
     this.corejs.ensureDynamicProto();
     return ('\$dynamic("' + name + '").' + type.get$jsname());
   }
   else {
     return ('' + type.get$jsname() + '.prototype.' + name);
   }
 }
+WorldGenerator.prototype._boundMethod = function(type, name) {
+  if (type.get$isSingletonNative()) {
+    return ('' + type.get$jsname() + '.' + name + '.bind(' + type.get$jsname() + ')');
+  }
+  else if (type.get$isHiddenNativeType()) {
+    return ('Object.getPrototype(this).' + type.get$jsname() + '.bind(this)');
+  }
+  else {
+    return ('' + type.get$jsname() + '.prototype.' + name + '.bind(this)');
+  }
+}
 WorldGenerator.prototype._maybeIsTest = function(onType, checkType) {
   var isSubtype = onType.isSubtypeOf(checkType);
   if (checkType.isTested) {
     this.writer.writeln(this._prototypeOf(onType, ('is\$' + checkType.get$jsname())) + (' = function(){return ' + isSubtype + '};'));
   }
   if (checkType.isChecked) {
     var body = 'return this';
     var checkName = ('assert\$' + checkType.get$jsname());
     if (!isSubtype) {
       body = $globals.world.objectType.varStubs.$index(checkName).get$body();
@@ skipping 66 matching lines @@
       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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var ct = $$list.$index($$i);
       this._maybeIsTest(type, ct);
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
     while (!worklist.isEmpty()) {
       var interface_ = worklist.removeLast();
       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.length; $$i++) {
+        for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
           var ct = $$list.$index($$i);
           this._maybeIsTest(type, ct);
         }
       }
       var $$list = interface_.get$interfaces();
       for (var $$i = interface_.get$interfaces().iterator$0(); $$i.hasNext$0(); ) {
         var other = $$i.next$0();
         if (!seen.contains(other)) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
   type.get$factories().forEach(this.get$_writeMethod());
   var $$list = this._orderValues(type.get$members());
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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._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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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) {
@@ skipping 23 matching lines @@
     if (property.getter != null) {
       this.writer.write(('get: ' + property.declaringType.get$jsname() + '.prototype.' + property.getter.get$jsname()));
       this.writer.writeln(property.setter == null ? '' : ',');
     }
     if (property.setter != null) {
       this.writer.writeln(('set: ' + property.declaringType.get$jsname() + '.prototype.' + property.setter.get$jsname()));
     }
     this.writer.exitBlock('});');
   }
 }
-WorldGenerator.prototype._writeMethod = function(method) {
-  if (method.generator != null) {
-    method.generator.writeDefinition(this.writer, null);
+WorldGenerator.prototype._writeMethod = function(m) {
+  if (m.generator != null) {
+    m.generator.writeDefinition(this.writer, null);
+  }
+  else if ((m instanceof MethodMember) && m.get$isNative() && m.get$dynamic().get$_providePropertySyntax() && !m.get$dynamic().get$_provideFieldSyntax()) {
+    MethodGenerator._maybeGenerateBoundGetter(m, this.writer);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
-  return WorldGenerator.prototype._writeMethod.bind(this);
+  return WorldGenerator.prototype._writeMethod.bind(this)
 }
 WorldGenerator.prototype.writeGlobals = function() {
   if (this.globals.get$length() > 0) {
     this.writer.comment('//  ********** Globals **************');
     var list = this.globals.getValues();
     list.sort$1((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     this.writer.enterBlock('function \$static_init(){');
@@ skipping 28 matching lines @@
 WorldGenerator.prototype._compareMembers = function(x, y) {
   if (x.get$span() != null && y.get$span() != null) {
     var spans = x.get$span().compareTo$1(y.get$span());
     if (spans != 0) return spans;
   }
   if (x.get$span() == null) return 1;
   if (y.get$span() == null) return -1;
   return x.get$name().compareTo$1(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
-  return WorldGenerator.prototype._compareMembers.bind(this);
+  return WorldGenerator.prototype._compareMembers.bind(this)
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = new HashMapImplementation();
   this._jsNames = new HashSetImplementation();
   // Initializers done
   if (this.get$isMethodScope()) {
@@ skipping 95 matching lines @@
   if (this.enclosingMethod != null) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
+MethodGenerator.prototype.get$method = function() { return this.method; };
+MethodGenerator.prototype.set$method = function(value) { return this.method = value; };
 MethodGenerator.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
 MethodGenerator.prototype.set$enclosingMethod = function(value) { return this.enclosingMethod = value; };
 MethodGenerator.prototype.get$needsThis = function() { return this.needsThis; };
 MethodGenerator.prototype.set$needsThis = function(value) { return this.needsThis = value; };
 MethodGenerator.prototype.get$library = function() {
   return this.method.get$library();
 }
 MethodGenerator.prototype.findMembers = function(name) {
   return this.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return value.needsTemp ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
-  if (this._freeTemps.length > 0) {
+  if (this._freeTemps.get$length() > 0) {
     name = this._freeTemps.removeLast();
   }
   else {
     name = '\$' + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
   return new Value(value.get$type(), name, value.span, false);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
   if ($eq(tmp, v)) {
@@ skipping 76 matching lines @@
   }
   else if (this.method.get$isStatic()) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock($globals.world.gen._prototypeOf(this.method.declaringType, this.method.get$jsname()) + (' = function' + _params + ' {'));
   }
   if (this.needsThis) {
     defWriter.writeln('var \$this = this; // closure support');
   }
-  if (this._usedTemps.get$length() > 0 || this._freeTemps.length > 0) {
+  if (this._usedTemps.get$length() > 0 || this._freeTemps.get$length() > 0) {
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if (names != null) {
     defWriter.exitBlock(('}).bind(null, ' + Strings.join(names, ", ") + ')'));
   }
   else if (this.get$isClosure() && this.method.name == '') {
     defWriter.exitBlock('})');
   }
   else {
     defWriter.exitBlock('}');
   }
   if (this.method.get$isConstructor() && this.method.get$constructorName() != '') {
     defWriter.writeln(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$constructorName() + '\$ctor.prototype = ') + ('' + this.method.declaringType.get$jsname() + '.prototype;'));
   }
   this._provideOptionalParamInfo(defWriter);
   if ((this.method instanceof MethodMember)) {
     var m = this.method;
-    if (m._providePropertySyntax) {
-      defWriter.enterBlock(('' + m.declaringType.get$jsname() + '.prototype') + ('.get\$' + m.get$jsname() + ' = function() {'));
-      defWriter.writeln(('return ' + m.declaringType.get$jsname() + '.prototype.') + ('' + m.get$jsname() + '.bind(this);'));
-      defWriter.exitBlock('}');
-      if (m._provideFieldSyntax) {
-        $globals.world.internalError('bound m accessed with field syntax');
-      }
+    MethodGenerator._maybeGenerateBoundGetter(m, defWriter);
+  }
+}
+MethodGenerator._maybeGenerateBoundGetter = function(m, defWriter) {
+  if (m._providePropertySyntax && !m.declaringType.get$isSingletonNative()) {
+    defWriter.enterBlock($globals.world.gen._prototypeOf(m.declaringType, "get\$" + m.get$jsname()) + ' = function() {');
+    defWriter.writeln('return ' + $globals.world.gen._boundMethod(m.declaringType, m.get$jsname()));
+    defWriter.exitBlock('}');
+    if (m._provideFieldSyntax) {
+      $globals.world.internalError(('bound "' + m.name + '" accessed with field syntax'), m.definition.span);
     }
   }
 }
 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.length; $$i++) {
+      for (var $$i = 0;$$i < $$list.get$length(); $$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.length > 0) {
+      if (optNames.get$length() > 0) {
         var start = '';
         if (meth.isStatic) {
           if (!meth.declaringType.get$isTop()) {
             start = meth.declaringType.get$jsname() + '.';
           }
         }
         else {
           start = meth.declaringType.get$jsname() + '.prototype.';
         }
         optNames.addAll$1(optValues);
@@ skipping 17 matching lines @@
         var cv = f.computeValue$0();
         if (cv != null) {
           initializers.add$1(('this.' + f.get$jsname() + ' = ' + cv.get$code()));
           initializedFields.add$1(f.get$name());
         }
       }
     }
   }
   this._paramCode = [];
   var $$list = this.method.get$parameters();
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var p = $$list.$index($$i);
     if (initializers != null && p.get$isInitializer()) {
       var field = this.method.declaringType.getMember(p.get$name());
       if (field == null) {
         $globals.world.error('bad this parameter - no matching field', p.get$definition().get$span());
       }
       if (!field.get$isField()) {
         $globals.world.error(('"this.' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
       var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false);
@@ skipping 53 matching lines @@
   }
   if (this.method.get$isConstructor() && initializerCall == null && !this.method.get$isNative()) {
     var parentType = this.method.declaringType.get$parent();
     if (parentType != null && !parentType.get$isObject()) {
       initializerCall = new CallExpression(new SuperExpression(this.method.get$span()), [], this.method.get$span());
     }
   }
   if (initializerCall != null) {
     var target = this._writeInitializerCall(initializerCall);
     if (!target.get$isSuper()) {
-      if (initializers.length > 0) {
+      if (initializers.get$length() > 0) {
         var $$list = this.method.get$parameters();
-        for (var $$i = 0;$$i < $$list.length; $$i++) {
+        for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
           var p = $$list.$index($$i);
           if (p.get$isInitializer()) {
             $globals.world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
             break;
           }
         }
       }
-      if (declaredInitializers != null && declaredInitializers.length > 1) {
+      if (declaredInitializers != null && declaredInitializers.get$length() > 1) {
         var init = $eq(declaredInitializers.$index(0), initializerCall) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
         $globals.world.error('no initialization allowed on redirecting constructors', init.get$span());
       }
       initializedFields = null;
     }
   }
   if (initializedFields != null) {
     for (var $$i = allMembers.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
       if (member.get$isField() && member.get$isFinal() && !member.get$isStatic() && !this.method.get$isNative() && !initializedFields.contains$1(member.get$name())) {
@@ skipping 38 matching lines @@
   $globals.world.gen.genMethod(m);
   var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
   if ($ne(target.get$type(), $globals.world.objectType)) {
     this.writer.writeln(('' + value.get$code() + ';'));
   }
   return target;
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var args = [];
   var seenLabel = false;
-  for (var $$i = 0;$$i < arguments.length; $$i++) {
+  for (var $$i = 0;$$i < arguments.get$length(); $$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.length > 0) {
+  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, true), 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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var stmt = $$list.$index($$i);
       stmt.visit$1(this);
     }
   }
   else {
     if (body != null) body.visit(this);
   }
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
@@ skipping 41 matching lines @@
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
   if (node.modifiers != null && $eq(node.modifiers.$index(0).get$kind(), 98/*TokenKind.FINAL*/)) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type, false);
   for (var i = 0;
-   i < node.names.length; i++) {
+   i < node.names.get$length(); i++) {
     var thisType = type;
     if (i > 0) {
       this.writer.write(', ');
     }
     var name = node.names.$index(i).get$name();
     var value = this.visitValue(node.values.$index(i));
     if (isFinal) {
       if (value == null) {
         $globals.world.error('no value specified for final variable', node.span);
       }
@@ skipping 124 matching lines @@
   else this.writer.write(';');
   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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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(true);
   node.body.visit(this);
   this._popBlock();
@@ skipping 13 matching lines @@
   this._pushBlock(true);
   var isFinal = this._isFinal(node.item.type);
   var item = this._scope.create(itemName, itemType, node.item.name.span, isFinal, false);
   var listVar = list;
   if (list.get$needsTemp()) {
     listVar = this._scope.create('\$list', list.get$type(), null, false, false);
     this.writer.writeln(('var ' + listVar.code + ' = ' + list.get$code() + ';'));
   }
   if (list.get$type().get$isList()) {
     var tmpi = this._scope.create('\$i', $globals.world.numType, null, false, false);
-    this.writer.enterBlock(('for (var ' + tmpi.get$code() + ' = 0;') + ('' + tmpi.get$code() + ' < ' + listVar.code + '.length; ' + tmpi.get$code() + '++) {'));
+    var listLength = listVar.get_(this, 'length', node.list);
+    this.writer.enterBlock(('for (var ' + tmpi.get$code() + ' = 0;') + ('' + tmpi.get$code() + ' < ' + listLength.get$code() + '; ' + tmpi.get$code() + '++) {'));
     var value = listVar.invoke(this, ':index', node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(('var ' + item.get$code() + ' = ' + value.get$code() + ';'));
   }
   else {
     this._pushBlock(false);
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
     var tmpi = this._scope.create('\$i', iterator.get$type(), null, false, false);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.get$code() + ' = ' + iterator.get$code() + '; ' + hasNext.get$code() + '; ) {'));
     this.writer.writeln(('var ' + item.get$code() + ' = ' + next.get$code() + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex, node) {
   var result = this._invokeNative("_toDartException", [ex]);
   this.writer.writeln(('' + ex.code + ' = ' + result.get$code() + ';'));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
-  if (node.catches.length == 1) {
+  if (node.catches.get$length() == 1) {
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
     var exType = this.method.resolveType(catch_.get$exception().get$type(), false);
     var ex = this._scope.declare(catch_.get$exception());
     this._scope.rethrow = ex;
     this.writer.nextBlock(('} catch (' + ex.get$code() + ') {'));
     if (catch_.get$trace() != null) {
       var trace = this._scope.declare(catch_.get$trace());
       this.writer.writeln(('var ' + trace.get$code() + ' = \$stackTraceOf(' + ex.get$code() + ');'));
       $globals.world.gen.corejs.useStackTraceOf = true;
     }
     this._genToDartException(ex, node);
     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.$index(0).get$body());
     this._popBlock();
   }
-  else if (node.catches.length > 0) {
+  else if (node.catches.get$length() > 0) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', $globals.world.varType, null, false, false);
     this._scope.rethrow = ex;
     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.writer.writeln(('var ' + trace.get$code() + ' = \$stackTraceOf(' + ex.get$code() + ');'));
       $globals.world.gen.corejs.useStackTraceOf = true;
     }
     this._genToDartException(ex, node);
     var needsRethrow = true;
     for (var i = 0;
-     i < node.catches.length; i++) {
+     i < node.catches.get$length(); i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
       var tmpType = this.method.resolveType(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();
       if (tmpType.get$isVarOrObject()) {
-        if (i + 1 < node.catches.length) {
+        if (i + 1 < node.catches.get$length()) {
           $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();
   }
   if (node.finallyBlock != null) {
     this.writer.nextBlock('} finally {');
     this._pushBlock(false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock();
   }
   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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var case_ = $$list.$index($$i);
     if (case_.get$label() != null) {
       $globals.world.error('unimplemented: labeled case statement', case_.get$span());
     }
     this._pushBlock(false);
     for (var i = 0;
-     i < case_.get$cases().length; i++) {
+     i < case_.get$cases().get$length(); i++) {
       var expr = case_.get$cases().$index(i);
       if (expr == null) {
-        if (i < case_.get$cases().length - 1) {
+        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.$index(node.cases.length - 1)) && !caseExits) {
-      var span = case_.get$statements().$index(case_.get$statements().length - 1).get$span();
+    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();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
   for (var i = 0;
-   i < statementList.length; i++) {
+   i < statementList.get$length(); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit$1(this);
-    if ($ne(stmt, statementList.$index(statementList.length - 1)) && exits) {
+    if ($ne(stmt, statementList.$index(statementList.get$length() - 1)) && exits) {
       $globals.world.warning('unreachable code', statementList.$index(i + 1).get$span());
     }
   }
   return exits;
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock('}');
@@ skipping 46 matching lines @@
   }
   else {
     return 'this';
   }
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
   if (this.enclosingMethod != null) {
     var outermostMethod = this._getOutermostMethod();
     outermostMethod._checkNonStatic$1(node);
     outermostMethod.set$needsThis(true);
-    return new Value(outermostMethod.method.get$declaringType(), '\$this', node != null ? node.span : null, false);
+    return new Value(outermostMethod.get$method().get$declaringType(), '\$this', node != null ? node.span : null, false);
   }
   else {
     this._checkNonStatic(node);
     return new Value(this.method.declaringType, 'this', node != null ? node.span : null, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = (node.func.name != null) ? node.func.name.name : '';
   var meth = this._makeLambdaMethod(name, node.func);
   var lambdaGen = new MethodGenerator(meth, this);
@@ skipping 49 matching lines @@
     return new Value($globals.world.nonNullBool, code, node.span, true);
   }
   else if (kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     if (x.get$isConst() && y.get$isConst()) {
       var xVal = x.get$actualValue();
       var yVal = y.get$actualValue();
       if (x.get$type().get$isString() && y.get$type().get$isString() && $ne(xVal.$index(0), yVal.$index(0))) {
         if ($eq(xVal.$index(0), '"')) {
-          xVal = xVal.substring$2(1, xVal.length - 1);
-          yVal = toDoubleQuote(yVal.substring$2(1, yVal.length - 1));
+          xVal = xVal.substring$2(1, xVal.get$length() - 1);
+          yVal = toDoubleQuote(yVal.substring$2(1, yVal.get$length() - 1));
         }
         else {
-          xVal = toDoubleQuote(xVal.substring$2(1, xVal.length - 1));
-          yVal = yVal.substring$2(1, yVal.length - 1);
+          xVal = toDoubleQuote(xVal.substring$2(1, xVal.get$length() - 1));
+          yVal = yVal.substring$2(1, yVal.get$length() - 1);
         }
       }
       var value = kind == 50/*TokenKind.EQ_STRICT*/ ? $eq(xVal, yVal) : $ne(xVal, yVal);
       return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, value, ("" + value), node.span);
     }
     if ($eq(x.get$code(), 'null') || $eq(y.get$code(), 'null')) {
       var op = node.op.toString().substring(0, 2);
       return new Value($globals.world.nonNullBool, ('' + x.get$code() + ' ' + op + ' ' + y.get$code()), node.span, true);
     }
     else {
@@ skipping 228 matching lines @@
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var typeRef = node.type;
   var constructorName = '';
   if (node.name != null) {
     constructorName = node.name.name;
   }
   if ($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference) && typeRef.get$names() != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.get$names());
     constructorName = names.removeLast$0().get$name();
-    if ($eq(names.length, 0)) names = null;
+    if ($eq(names.get$length(), 0)) names = null;
     typeRef = new NameTypeReference(typeRef.get$isFinal(), typeRef.get$name(), names, typeRef.get$span());
   }
   var type = this.method.resolveType(typeRef, true);
   if (type.get$isTop()) {
     type = type.get$library().findTypeByName$1(constructorName);
     constructorName = '';
   }
   if ((type instanceof ParameterType)) {
     $globals.world.error('cannot instantiate a type parameter', node.span);
     return this._makeMissingValue(constructorName);
   }
   var m = type.getConstructor$1(constructorName);
   if (m == null) {
     var name = type.get$jsname();
     if (type.get$isVar()) {
       name = typeRef.get$name().get$name();
     }
     $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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$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 Value.type$ctor(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argsCode = [];
   var argValues = [];
   var type = null;
   if (node.type != null) {
     type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(0);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error('type parameter cannot be used in const list literals');
     }
   }
   var $$list = node.values;
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var item = $$list.$index($$i);
     var arg = this.visitTypedValue(item, type);
     argValues.add$1(arg);
     if (node.isConst) {
       if (!arg.get$isConst()) {
         $globals.world.error('const list can only contain const values', item.get$span());
         argsCode.add$1(arg.get$code());
       }
       else {
         argsCode.add$1(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add$1(arg.get$code());
     }
   }
   $globals.world.get$coreimpl().types.$index('ListFactory').markUsed$0();
   var code = ('[' + Strings.join(argsCode, ", ") + ']');
   var value = new Value($globals.world.listType, code, node.span, true);
   if (node.isConst) {
     var immutableList = $globals.world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor$1('from');
     var result = immutableListCtor.invoke$4(this, node, new Value.type$ctor(value.get$type(), node.span), new Arguments(null, [value]));
     value = $globals.world.gen.globalForConst(ConstListValue.ConstListValue$factory(immutableList, argValues, ('const ' + code), result.get$code(), node.span), argValues);
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
-  if (node.items.length == 0 && !node.isConst) {
+  if (node.items.get$length() == 0 && !node.isConst) {
     return $globals.world.mapType.getConstructor('').invoke$4(this, node, new Value.type$ctor($globals.world.mapType, node.span), Arguments.get$EMPTY());
   }
   var argValues = [];
   var argsCode = [];
   var type = null;
   if (node.type != null) {
     type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(1);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error('type parameter cannot be used in const map literals');
     }
   }
   for (var i = 0;
-   i < node.items.length; i += 2) {
+   i < node.items.get$length(); i += 2) {
     var key = this.visitTypedValue(node.items.$index(i), $globals.world.stringType);
     var valueItem = node.items.$index(i + 1);
     var value = this.visitTypedValue(valueItem, type);
     argValues.add$1(key);
     argValues.add$1(value);
     if (node.isConst) {
       if (!key.get$isConst() || !value.get$isConst()) {
         $globals.world.error('const map can only contain const values', valueItem.get$span());
         argsCode.add$1(key.get$code());
         argsCode.add$1(value.get$code());
@@ skipping 81 matching lines @@
     var items = [];
     var $$list = node.value;
     for (var $$i = node.value.iterator$0(); $$i.hasNext$0(); ) {
       var item = $$i.next$0();
       var val = this.visitValue(item);
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.get$code();
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression) || (item instanceof PostfixExpression) || this._isUnaryIncrement(item)) {
         code = ('(' + code + ')');
       }
-      if ($eq(items.length, 0) || ($ne(code, "''") && $ne(code, '""'))) {
+      if ($eq(items.get$length(), 0) || ($ne(code, "''") && $ne(code, '""'))) {
         items.add$1(code);
       }
     }
     return new Value(type, ('(' + Strings.join(items, " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if (type.get$isString()) {
     if (text.startsWith$1('@')) {
       text = MethodGenerator._escapeString(parseStringLiteral(text));
       text = ('"' + text + '"');
@@ skipping 41 matching lines @@
 }
 Arguments.prototype.get$values = function() { return this.values; };
 Arguments.prototype.set$values = function(value) { return this.values = value; };
 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.length;
+  return this.values.get$length();
 }
-Object.defineProperty(Arguments.prototype, "length", {
-  get: Arguments.prototype.get$length
-});
 Arguments.prototype.getName = function(i) {
   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.$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.length; i++) {
+       i < this.nodes.get$length(); i++) {
         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.$index(i).get$code());
   }
   Arguments.removeTrailingNulls(argsCode);
   return Strings.join(argsCode, ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
-  while (argsCode.length > 0 && $eq(argsCode.last(), 'null')) {
+  while (argsCode.get$length() > 0 && $eq(argsCode.last(), 'null')) {
     argsCode.removeLast();
   }
 }
 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 138 matching lines @@
   }
   else {
     this.types.$setindex(name, new DefinedType(name, this, definition, isClass));
   }
   return this.types.$index(name);
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if (result == null) return null;
   if (type.names != null) {
-    if (type.names.length > 1) {
+    if (type.names.get$length() > 1) {
       return null;
     }
     if (!result.get$isTop()) {
       return null;
     }
     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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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)) {
@@ skipping 44 matching lines @@
   var newRet = this.topType.getMember(name);
   if (newRet != null) {
     if (ret != null && $ne(ret, newRet)) {
       $globals.world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
     }
     else {
       ret = newRet;
     }
   }
   var $$list = this.imports;
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var imported = $$list.$index($$i);
     if (imported.get$prefix() == null) {
       newRet = imported.get$library().get$topType().getMember$1(name);
       if (newRet != null) {
         if (ret != null && $ne(ret, newRet)) {
           $globals.world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
         }
         else {
           ret = newRet;
         }
@@ skipping 115 matching lines @@
       else {
         $globals.world.error('already specified library name', node.span);
       }
       break;
 
     case "import":
 
       this.seenImport = true;
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
-      if (node.arguments.length > 2 || node.arguments.length == 2 && prefix == null) {
-        $globals.world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.length), node.span);
+      if (node.arguments.get$length() > 2 || node.arguments.get$length() == 2 && prefix == null) {
+        $globals.world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.get$length()), node.span);
       }
       else if (prefix != null && prefix.indexOf$1('.') >= 0) {
         $globals.world.error('library prefix canot contain "."', node.span);
       }
       else if (this.seenSource || this.seenResource) {
         $globals.world.error('#imports must come before any #source or #resource', node.span);
       }
       if ($eq(prefix, '')) prefix = null;
       var filename = this.library.makeFullPath(name);
       if (this.library.imports.some((function (li) {
@@ skipping 28 matching lines @@
       this.getFirstStringArg(node);
       break;
 
     default:
 
       $globals.world.error(('unknown directive: ' + node.name.name), node.span);
 
   }
 }
 _LibraryVisitor.prototype.getSingleStringArg = function(node) {
-  if (node.arguments.length != 1) {
-    $globals.world.error(('expected exactly one argument but found ' + node.arguments.length), node.span);
+  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.length < 1) {
-    $globals.world.error(('expected at least one argument but found ' + node.arguments.length), node.span);
+  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.$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((function (a) {
     return a.get$label() != null && $eq(a.get$label().get$name(), argName);
   })
   );
-  if ($eq(args.length, 0)) {
+  if ($eq(args.get$length(), 0)) {
     return null;
   }
-  if (args.length > 1) {
-    $globals.world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
+  if (args.get$length() > 1) {
+    $globals.world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.get$length(), node.span);
   }
   for (var $$i = args.iterator$0(); $$i.hasNext$0(); ) {
     var arg = $$i.next$0();
     return this._parseStringArgument(arg);
   }
 }
 _LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
   if (!(expr instanceof LiteralExpression) || !expr.get$type().get$type().get$isString()) {
     $globals.world.error('expected string', expr.get$span());
   }
   return parseStringLiteral(expr.get$value());
 }
 _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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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);
 }
 _LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod$2(':call', node.func);
 }
 _LibraryVisitor.prototype.addSource$1 = _LibraryVisitor.prototype.addSource;
 // ********** Code for Parameter **************
 function Parameter(definition, method) {
   this.isInitializer = false
   this.definition = definition;
   this.method = method;
   // Initializers done
 }
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
+Parameter.prototype.get$method = function() { return this.method; };
+Parameter.prototype.set$method = function(value) { return this.method = value; };
 Parameter.prototype.get$name = function() { return this.name; };
 Parameter.prototype.set$name = function(value) { return this.name = value; };
 Parameter.prototype.get$type = function() { return this.type; };
 Parameter.prototype.set$type = function(value) { return this.type = value; };
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
 Parameter.prototype.set$isInitializer = function(value) { return this.isInitializer = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function() {
   this.name = this.definition.name.name;
   if (this.name.startsWith('this.')) {
     this.name = this.name.substring(5);
     this.isInitializer = true;
   }
   this.type = this.method.resolveType(this.definition.type, false);
   if (this.definition.value != null) {
     if (!this.get$hasDefaultValue()) return;
     if (this.method.name == ':call') {
-      if (this.method.get$definition().get$body() == null) {
+      if (this.method.get$definition().get$body() == null && !this.method.get$isNative()) {
         $globals.world.error('default value not allowed on function type', this.definition.span);
       }
     }
     else if (this.method.get$isAbstract()) {
       $globals.world.error('default value not allowed on abstract methods', this.definition.span);
     }
   }
   else if (this.isInitializer && !this.method.get$isConstructor()) {
     $globals.world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
@@ skipping 67 matching lines @@
 }
 Member.prototype.get$isFactory = function() {
   return false;
 }
 Member.prototype.get$isOperator = function() {
   return this.name.startsWith(':');
 }
 Member.prototype.get$isCallMethod = function() {
   return this.name == ':call';
 }
-Member.prototype.get$prefersPropertySyntax = function() {
-  return true;
+Member.prototype.get$requiresPropertySyntax = function() {
+  return false;
 }
 Member.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 Member.prototype.get$isNative = function() {
   return false;
 }
 Member.prototype.get$constructorName = function() {
   $globals.world.internalError('can not be a constructor', this.get$span());
 }
@@ skipping 144 matching lines @@
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
 FieldMember.prototype.get$type = function() { return this.type; };
 FieldMember.prototype.set$type = function(value) { return this.type = value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isFinal = function() { return this.isFinal; };
 FieldMember.prototype.set$isFinal = function(value) { return this.isFinal = value; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
 FieldMember.prototype.set$isNative = function(value) { return this.isNative = value; };
+FieldMember.prototype.get$_providePropertySyntax = function() { return this._providePropertySyntax; };
+FieldMember.prototype.set$_providePropertySyntax = function(value) { return this._providePropertySyntax = value; };
 FieldMember.prototype.override = function(other) {
   if (!Member.prototype.override.call(this, other)) return false;
   if (other.get$isProperty()) {
     return true;
   }
   else {
     $globals.world.error('field can not override anything but property', this.get$span(), other.get$span());
     return false;
   }
 }
-FieldMember.prototype.get$prefersPropertySyntax = function() {
-  return false;
-}
-FieldMember.prototype.get$requiresFieldSyntax = function() {
-  return this.isNative;
-}
 FieldMember.prototype.provideFieldSyntax = function() {
 
 }
 FieldMember.prototype.providePropertySyntax = function() {
   this._providePropertySyntax = true;
 }
 FieldMember.prototype.get$span = function() {
   return this.definition == null ? null : this.definition.span;
 }
 FieldMember.prototype.get$returnType = function() {
   return this.type;
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !this.isFinal;
 }
 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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
       if ($eq(mod.get$kind(), 86/*TokenKind.STATIC*/)) {
         if (this.isStatic) {
           $globals.world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($eq(mod.get$kind(), 98/*TokenKind.FINAL*/)) {
         if (this.isFinal) {
           $globals.world.error('duplicate final modifier', mod.get$span());
@@ skipping 75 matching lines @@
     else {
       return new Value(this.type, ('\$globals.' + this.declaringType.get$jsname() + '_' + this.get$jsname()), node.span, true);
     }
   }
   else if (target.get$isConst() && this.isFinal) {
     var constTarget = (target instanceof GlobalValue) ? target.get$dynamic().get$exp() : target;
     if ((constTarget instanceof ConstObjectValue)) {
       return constTarget.get$fields().$index(this.name);
     }
     else if ($eq(constTarget.get$type(), $globals.world.stringType) && this.name == 'length') {
-      return new Value(this.type, ('' + constTarget.get$actualValue().length), node.span, true);
+      return new Value(this.type, ('' + constTarget.get$actualValue().get$length()), node.span, true);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname()), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.get$code() + ' = ' + value.code), node.span, true);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
@@ skipping 14 matching lines @@
 $inherits(PropertyMember, Member);
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   // Initializers done
   Member.call(this, name, declaringType);
 }
 PropertyMember.prototype.get$getter = function() { return this.getter; };
 PropertyMember.prototype.set$getter = function(value) { return this.getter = value; };
 PropertyMember.prototype.get$setter = function() { return this.setter; };
 PropertyMember.prototype.set$setter = function(value) { return this.setter = value; };
+PropertyMember.prototype.get$_provideFieldSyntax = function() { return this._provideFieldSyntax; };
+PropertyMember.prototype.set$_provideFieldSyntax = function(value) { return this._provideFieldSyntax = value; };
 PropertyMember.prototype.get$span = function() {
   return this.getter != null ? this.getter.get$span() : null;
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
 PropertyMember.prototype.get$canSet = function() {
   return this.setter != null;
 }
-PropertyMember.prototype.get$prefersPropertySyntax = function() {
-  return true;
-}
-PropertyMember.prototype.get$requiresFieldSyntax = function() {
-  return false;
+PropertyMember.prototype.get$requiresPropertySyntax = function() {
+  return this.declaringType.get$isClass();
 }
 PropertyMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 PropertyMember.prototype.providePropertySyntax = function() {
-
+  if (this._overriddenField != null && this._overriddenField.get$isNative()) {
+    this.provideFieldSyntax();
+  }
 }
 PropertyMember.prototype.get$isStatic = function() {
   return this.getter == null ? this.setter.isStatic : this.getter.isStatic;
 }
 PropertyMember.prototype.get$isProperty = function() {
   return true;
 }
 PropertyMember.prototype.get$returnType = function() {
   return this.getter == null ? this.setter.returnType : this.getter.returnType;
 }
@@ skipping 35 matching lines @@
   }
   else {
     parent = parentMember;
   }
   if (this.getter == null) this.getter = parent.getter;
   if (this.setter == null) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function() {
   if (this.getter != null) {
     this.getter.resolve();
-    if (this.getter.parameters.length != 0) {
+    if (this.getter.parameters.get$length() != 0) {
       $globals.world.error('getter methods should take no arguments', this.getter.definition.span);
     }
     if (this.getter.returnType.get$isVoid()) {
       $globals.world.warning('getter methods should not be void', this.getter.definition.returnType.span);
     }
   }
   if (this.setter != null) {
     this.setter.resolve();
-    if (this.setter.parameters.length != 1) {
+    if (this.setter.parameters.get$length() != 1) {
       $globals.world.error('setter methods should take a single argument', this.setter.definition.span);
     }
     if (!this.setter.returnType.get$isVoid() && this.setter.definition.returnType != null) {
       $globals.world.warning('setter methods should be void', this.setter.definition.returnType.span);
     }
   }
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
@@ skipping 10 matching lines @@
 PropertyMember.prototype.resolve$0 = PropertyMember.prototype.resolve;
 // ********** Code for ConcreteMember **************
 $inherits(ConcreteMember, Member);
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   // Initializers done
   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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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);
     }
   }
 }
@@ skipping 36 matching lines @@
 }
 ConcreteMember.prototype.get$isField = function() {
   return this.baseMember.get$isField();
 }
 ConcreteMember.prototype.get$isMethod = function() {
   return this.baseMember.get$isMethod();
 }
 ConcreteMember.prototype.get$isProperty = function() {
   return this.baseMember.get$isProperty();
 }
-ConcreteMember.prototype.get$prefersPropertySyntax = function() {
-  return this.baseMember.get$prefersPropertySyntax();
+ConcreteMember.prototype.get$requiresPropertySyntax = function() {
+  return this.baseMember.get$requiresPropertySyntax();
 }
 ConcreteMember.prototype.get$requiresFieldSyntax = function() {
   return this.baseMember.get$requiresFieldSyntax();
 }
 ConcreteMember.prototype.provideFieldSyntax = function() {
   return this.baseMember.provideFieldSyntax();
 }
 ConcreteMember.prototype.providePropertySyntax = function() {
   return this.baseMember.providePropertySyntax();
 }
@@ skipping 86 matching lines @@
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 MethodMember.prototype.get$isAbstract = function() { return this.isAbstract; };
 MethodMember.prototype.set$isAbstract = function(value) { return this.isAbstract = value; };
 MethodMember.prototype.get$isConst = function() { return this.isConst; };
 MethodMember.prototype.set$isConst = function(value) { return this.isConst = value; };
 MethodMember.prototype.get$isFactory = function() { return this.isFactory; };
 MethodMember.prototype.set$isFactory = function(value) { return this.isFactory = value; };
 MethodMember.prototype.get$isLambda = function() { return this.isLambda; };
 MethodMember.prototype.set$isLambda = function(value) { return this.isLambda = value; };
+MethodMember.prototype.get$_providePropertySyntax = function() { return this._providePropertySyntax; };
+MethodMember.prototype.set$_providePropertySyntax = function(value) { return this._providePropertySyntax = value; };
+MethodMember.prototype.get$_provideFieldSyntax = function() { return this._provideFieldSyntax; };
+MethodMember.prototype.set$_provideFieldSyntax = function(value) { return this._provideFieldSyntax = value; };
 MethodMember.prototype.get$initDelegate = function() { return this.initDelegate; };
 MethodMember.prototype.set$initDelegate = function(value) { return this.initDelegate = value; };
 MethodMember.prototype.get$isConstructor = function() {
   return this.name == this.declaringType.name;
 }
 MethodMember.prototype.get$isMethod = function() {
   return !this.get$isConstructor();
 }
 MethodMember.prototype.get$isNative = function() {
   return this.definition.nativeBody != null;
 }
 MethodMember.prototype.get$canGet = function() {
-  return false;
+  return true;
 }
 MethodMember.prototype.get$canSet = function() {
   return false;
 }
+MethodMember.prototype.get$requiresPropertySyntax = function() {
+  return true;
+}
 MethodMember.prototype.get$span = function() {
   return this.definition == null ? null : this.definition.span;
 }
 MethodMember.prototype.get$constructorName = function() {
   var returnType = this.definition.returnType;
   if (returnType == null) return '';
   if ((returnType instanceof GenericTypeReference)) {
     return '';
   }
   if (returnType.get$names() != null) {
@@ skipping 18 matching lines @@
   if (other.get$isMethod()) {
     return true;
   }
   else {
     $globals.world.error('method can only override methods', this.get$span(), other.get$span());
     return false;
   }
 }
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
-  if (bareCount > this.parameters.length) return false;
-  if (bareCount == this.parameters.length) {
+  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.$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.length; i++) {
+   i < this.parameters.get$length(); i++) {
     var p = this.parameters.$index(i);
     if (p.get$isOptional() && $eq(p.get$name(), name)) {
       return i;
     }
   }
   return -1;
 }
-MethodMember.prototype.get$prefersPropertySyntax = function() {
-  return true;
-}
-MethodMember.prototype.get$requiresFieldSyntax = function() {
-  return false;
-}
 MethodMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
   this._providePropertySyntax = true;
 }
 MethodMember.prototype._set = function(context, node, target, value, isDynamic) {
   $globals.world.error('cannot set method', node.span);
 }
 MethodMember.prototype._get = function(context, node, target, isDynamic) {
   this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
   if (this.isStatic) {
     this.declaringType.markUsed();
     var type = this.declaringType.get$isTop() ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + this.get$jsname()), node.span, true);
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), node.span, true);
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!args.get$hasNames()) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
-   i < this.parameters.length; i++) {
+   i < this.parameters.get$length(); i++) {
     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.$index(i);
     if (arg.needsConversion$1(this.parameters.$index(i).get$type())) {
       return true;
     }
   }
-  if (bareCount < this.parameters.length) {
+  if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
-     i < this.parameters.length; i++) {
+     i < this.parameters.get$length(); i++) {
       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, 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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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.isType && (this.get$isConstructor() || target.isSuper)) {
     argsCode.add$1('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
    i < bareCount; i++) {
     var arg = args.values.$index(i);
-    if (i >= this.parameters.length) {
-      var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.length, false);
+    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, args.nodes.$index(i).get$span());
     }
     arg = arg.convertTo$4(context, this.parameters.$index(i).get$type(), node, isDynamic);
     if (this.isConst && arg.get$isConst()) {
       argsCode.add$1(arg.get$canonicalCode());
     }
     else {
       argsCode.add$1(arg.get$code());
     }
   }
   var namedArgsUsed = 0;
-  if (bareCount < this.parameters.length) {
+  if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
-     i < this.parameters.length; i++) {
+     i < this.parameters.get$length(); i++) {
       var arg = args.getValue(this.parameters.$index(i).get$name());
       if (arg == null) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
         arg = arg.convertTo$4(context, this.parameters.$index(i).get$type(), node, isDynamic);
         namedArgsUsed++;
       }
       if (arg == null || !this.parameters.$index(i).get$isOptional()) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
@@ skipping 43 matching lines @@
     }
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if (target.get$isConst()) {
     if ((target instanceof GlobalValue)) {
       target = target.get$dynamic().get$exp();
     }
     if (this.name == 'get:length') {
       if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
-        code = ('' + target.get$dynamic().get$values().length);
+        code = ('' + target.get$dynamic().get$values().get$length());
       }
     }
     else if (this.name == 'isEmpty') {
       if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
         code = ('' + target.get$dynamic().get$values().isEmpty$0());
       }
     }
   }
   if (this.name == 'get:typeName' && $eq(this.declaringType.get$library(), $globals.world.get$dom())) {
     $globals.world.gen.corejs.ensureTypeNameOf();
@@ skipping 12 matching lines @@
       return this._invokeConstConstructor(node, code, target, args);
     }
     else {
       return new Value(target.get$type(), code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var fields = new HashMapImplementation();
   for (var i = 0;
-   i < this.parameters.length; i++) {
+   i < this.parameters.get$length(); i++) {
     var param = this.parameters.$index(i);
     if (param.get$isInitializer()) {
       var value = null;
       if (i < args.get$length()) {
         value = args.values.$index(i);
       }
       else {
         value = args.getValue(param.get$name());
         if (value == null) {
           value = param.get$value();
         }
       }
       fields.$setindex(param.get$name(), value);
     }
   }
   if (this.definition.initializers != null) {
     this.generator._pushBlock(false);
     for (var j = 0;
-     j < this.definition.formals.length; j++) {
+     j < this.definition.formals.get$length(); j++) {
       var name = this.definition.formals.$index(j).get$name().get$name();
       var value = null;
       if (j < args.get$length()) {
         value = args.values.$index(j);
       }
       else {
         value = args.getValue(this.parameters.$index(j).get$name());
         if (value == null) {
           value = this.parameters.$index(j).get$value();
         }
       }
       this.generator._scope._vars.$setindex(name, value);
     }
     var $$list = this.definition.initializers;
-    for (var $$i = 0;$$i < $$list.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var init = $$list.$index($$i);
       if ((init instanceof CallExpression)) {
         var delegateArgs = this.generator._makeArgs(init.get$arguments());
         var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
         if ((init.get$target() instanceof ThisExpression)) {
           return value;
         }
         else {
           if ((value instanceof GlobalValue)) {
             value = value.get$exp();
@@ skipping 54 matching lines @@
         var op = TokenKind.rawOperatorFromMethod(this.name);
         code = ('' + target.code + ' ' + op + ' ' + argsCode.$index(0));
       }
       return new Value(this.get$inferredResult(), code, node.span, true);
     }
     else {
       var value;
       var val0, val1, ival0, ival1;
       val0 = target.get$dynamic().get$actualValue();
       ival0 = val0.toInt();
-      if (args.values.length > 0) {
+      if (args.values.get$length() > 0) {
         val1 = args.values.$index(0).get$dynamic().get$actualValue();
         ival1 = val1.toInt();
       }
       switch (this.name) {
         case ':negate':
 
           value = -val0;
           break;
 
         case ':add':
@@ skipping 144 matching lines @@
   }
   else if (this.name == ':setindex') {
     $globals.world.gen.corejs.useSetIndex = true;
   }
   var argsString = Strings.join(argsCode, ', ');
   return new Value(this.get$inferredResult(), ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
 }
 MethodMember.prototype._normConcat = function(a, b) {
   var val0 = a.get$dynamic().get$actualValue();
   var quote0 = val0.$index(0);
-  val0 = val0.substring$2(1, val0.length - 1);
+  val0 = val0.substring$2(1, val0.get$length() - 1);
   var val1 = b.get$dynamic().get$actualValue();
   var quote1 = null;
   if (b.get$type().get$isString()) {
     quote1 = val1.$index(0);
-    val1 = val1.substring$2(1, val1.length - 1);
+    val1 = val1.substring$2(1, val1.get$length() - 1);
   }
   var value;
   if ($eq(quote0, quote1) || quote1 == null) {
     value = ('' + quote0 + val0 + val1 + quote0);
   }
   else if ($eq(quote0, '"')) {
     value = ('' + quote0 + val0 + toDoubleQuote(val1) + quote0);
   }
   else {
     value = ('' + quote1 + toDoubleQuote(val0) + val1 + quote1);
   }
   return value;
 }
 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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
       if ($eq(mod.get$kind(), 86/*TokenKind.STATIC*/)) {
         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/*TokenKind.CONST*/)) {
         if (this.isConst) {
           $globals.world.error('duplicate const modifier', mod.get$span());
@@ skipping 25 matching lines @@
   if (this.isFactory) {
     this.isStatic = true;
   }
   if (this.definition.typeParameters != null) {
     if (!this.isFactory) {
       $globals.world.error('Only factories are allowed to have explicit type parameters', this.definition.typeParameters.$index(0).get$span());
     }
     else {
       this.typeParameters = this.definition.typeParameters;
       var $$list = this.definition.typeParameters;
-      for (var $$i = 0;$$i < $$list.length; $$i++) {
+      for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
         var tp = $$list.$index($$i);
         tp.set$enclosingElement(this);
         tp.resolve$0();
       }
     }
   }
   if (this.get$isOperator() && this.isStatic && !this.get$isCallMethod()) {
     $globals.world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if (this.isAbstract) {
@@ skipping 10 matching lines @@
     }
   }
   if (this.get$isConstructor() && !this.isFactory) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = this.resolveType(this.definition.returnType, false);
   }
   this.parameters = [];
   var $$list = this.definition.formals;
-  for (var $$i = 0;$$i < $$list.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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) {
@@ skipping 32 matching lines @@
   this.members = [member];
   this.jsname = member.get$jsname();
   this.isVar = isVar;
   // Initializers done
 }
 MemberSet.prototype.get$name = function() { return this.name; };
 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.length);
+  return ('' + this.name + ':' + this.members.get$length());
 }
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
     return (m instanceof MethodMember);
   })
   );
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
-  return this.members.length == 1 && this.members.$index(0).get$isStatic();
+  return this.members.get$length() == 1 && this.members.$index(0).get$isStatic();
 }
 MemberSet.prototype.get$isOperator = function() {
   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.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), node.span, true);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if (this._treatAsField == null) {
-    this._treatAsField = !this.isVar;
+    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.length; $$i++) {
-      var member = $$list.$index($$i);
-      if (member.get$requiresFieldSyntax()) {
-        this._treatAsField = true;
-        break;
-      }
-      if (member.get$prefersPropertySyntax()) {
-        this._treatAsField = false;
-      }
-    }
-    var $$list = this.members;
-    for (var $$i = 0;$$i < $$list.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$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;
   var targets = this.members.filter((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, true);
   }
   else {
-    if (this.members.length == 1) {
+    if (this.members.get$length() == 1) {
       return this.members.$index(0)._get$4(context, node, target, isDynamic);
     }
-    else if ($eq(targets.length, 1)) {
+    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');
     }
@@ skipping 15 matching lines @@
   })
   );
   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, true);
   }
   else {
-    if (this.members.length == 1) {
+    if (this.members.get$length() == 1) {
       return this.members.$index(0)._set$5(context, node, target, value, isDynamic);
     }
-    else if ($eq(targets.length, 1)) {
+    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.code == null) {
     if (this.get$treatAsField()) {
       return new Value(returnValue.get$type(), ('' + target.code + '.' + this.jsname + ' = ' + value.code), node.span, true);
     }
     else {
       return new Value(returnValue.get$type(), ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, true);
     }
   }
   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.length == 1) {
+  if (this.members.get$length() == 1) {
     return this.members.$index(0).invoke$5(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
-  if ($eq(targets.length, 1)) {
+  if ($eq(targets.get$length(), 1)) {
     return targets.$index(0).invoke$5(context, node, target, args, isDynamic);
   }
   var returnValue = null;
   for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     var res = member.invoke$4$isDynamic(context, node, target, args, true);
     returnValue = this._tryUnion(returnValue, res, node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'method');
@@ skipping 10 matching lines @@
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invokeSpecial = function(target, args, returnType) {
   var argsString = args.getCode();
   if (this.name == ':index' || this.name == ':setindex') {
     return new Value(returnType, ('' + target.code + '.' + this.jsname + '(' + argsString + ')'), target.span, true);
   }
   else {
-    if (argsString.length > 0) argsString = (', ' + argsString);
+    if (argsString.get$length() > 0) argsString = (', ' + argsString);
     $globals.world.gen.corejs.useOperator(this.name);
     return new Value(returnType, ('' + this.jsname + '(' + target.code + argsString + ')'), target.span, true);
   }
 }
 MemberSet.prototype.invokeOnVar = function(context, node, target, args) {
   var member = this.getVarMember(context, node, args);
   return member.invoke$4(context, node, target, args);
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
@@ skipping 101 matching lines @@
 Token.prototype.get$kind = function() { return this.kind; };
 Token.prototype.get$end = function() { return this.end; };
 Token.prototype.get$start = function() { return this.start; };
 Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($ne(kindText, actualText)) {
-    if (actualText.length > 10) {
+    if (actualText.get$length() > 10) {
       actualText = actualText.substring$2(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return kindText;
   }
 }
 Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
 Token.prototype.end$0 = function() {
-  return this.end();
+  return this.end.call$0();
 };
 Token.prototype.start$0 = function() {
-  return this.start();
+  return this.start.call$0();
 };
 Token.prototype.toString$0 = Token.prototype.toString;
 // ********** Code for ErrorToken **************
 $inherits(ErrorToken, Token);
 function ErrorToken(kind, source, start, end, message) {
   this.message = message;
   // Initializers done
   Token.call(this, kind, source, start, end);
 }
 ErrorToken.prototype.get$message = function() { return this.message; };
@@ skipping 20 matching lines @@
       starts.add$1(index);
     }
     starts.add$1(this.get$text().length + 1);
     this._lineStarts = starts;
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = 0;
-   i < starts.length; i++) {
+   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().$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 + ':' + (line + 1) + ':' + (column + 1) + ': ' + message));
   if (includeText) {
     buf.add$1('\n');
     var textLine;
-    if ((line + 2) < this._lineStarts.length) {
+    if ((line + 2) < this._lineStarts.get$length()) {
       textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index(line + 1));
     }
     else {
       textLine = this.get$text().substring(this._lineStarts.$index(line)) + '\n';
     }
-    var toColumn = Math.min(column + (end - start), textLine.length);
+    var toColumn = Math.min(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 {
       buf.add$1(textLine);
     }
@@ skipping 43 matching lines @@
 }
 SourceSpan.prototype.compareTo = function(other) {
   if ($eq(this.file, other.file)) {
     var d = this.start - other.start;
     return d == 0 ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 SourceSpan.prototype.compareTo$1 = SourceSpan.prototype.compareTo;
 SourceSpan.prototype.end$0 = function() {
-  return this.end();
+  return this.end.call$0();
 };
 SourceSpan.prototype.start$0 = function() {
-  return this.start();
+  return this.start.call$0();
 };
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = -1;
   // Initializers done
 }
 InterpStack.prototype.get$previous = function() { return this.previous; };
@@ skipping 1938 matching lines @@
   this._inhibitLambda = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   this._inhibitLambda = false;
   return ret;
 }
 Parser.prototype.get$initializers = function() {
-  return Parser.prototype.initializers.bind(this);
+  return Parser.prototype.initializers.bind(this)
 }
 Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if (this._maybeEat(9/*TokenKind.ARROW*/)) {
     var expr = this.expression();
     if (!inExpression) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
@@ skipping 86 matching lines @@
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   else if (typeParams == null) {
-    if (names.length > 1) {
+    if (names.get$length() > 1) {
       name = names.removeLast$0();
     }
     else {
       name = new Identifier('', names.$index(0).get$span());
     }
   }
   else {
     name = new Identifier('', names.$index(0).get$span());
   }
-  if (names.length > 1) {
+  if (names.get$length() > 1) {
     this._error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di, typeParams);
 }
 Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 89/*TokenKind.BREAK*/:
 
@@ skipping 258 matching lines @@
       this._eat(8/*TokenKind.COLON*/);
     }
     else if (this._maybeEat(94/*TokenKind.DEFAULT*/)) {
       cases.add$1();
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
-  if ($eq(cases.length, 0)) {
+  if ($eq(cases.get$length(), 0)) {
     this._error('case or default');
   }
   var stmts = [];
   while (!this._peekCaseEnd()) {
     stmts.add$1(this.statement());
     if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 90/*TokenKind.CASE*/, 94/*TokenKind.DEFAULT*/)) {
       break;
     }
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
@@ skipping 194 matching lines @@
     do {
       args.add$1(this.argument());
     }
     while (this._maybeEat(11/*TokenKind.COMMA*/))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   this._inhibitLambda = saved;
   return args;
 }
 Parser.prototype.get$arguments = function() {
-  return Parser.prototype.arguments.bind(this);
+  return Parser.prototype.arguments.bind(this)
 }
 Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       return this.finishCallOrLambdaExpression(expr);
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
@@ skipping 171 matching lines @@
     var token = this._next();
     var text = token.get$text();
     if (startQuote == null) {
       if (isMultilineString(text)) {
         endQuote = text.substring$2(0, 3);
         startQuote = endQuote + '\n';
       }
       else {
         startQuote = endQuote = text.$index(0);
       }
-      text = text.substring$2(0, text.length - 1) + endQuote;
+      text = text.substring$2(0, text.get$length() - 1) + endQuote;
     }
     else {
-      text = startQuote + text.substring$2(0, text.length - 1) + endQuote;
+      text = startQuote + text.substring$2(0, text.get$length() - 1) + endQuote;
     }
     lits.add$1(this.makeStringLiteral(text, token.get$span()));
     if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
       lits.add$1(this.expression());
       this._eat(7/*TokenKind.RBRACE*/);
     }
     else if (this._maybeEat(109/*TokenKind.THIS*/)) {
       lits.add$1(new ThisExpression(this._previousToken.get$span()));
     }
     else {
@@ skipping 53 matching lines @@
 Parser.prototype._atClosureParameters = function() {
   if (this._inhibitLambda) return false;
   var after = this._peekAfterCloseParen();
   return after.kind == 9/*TokenKind.ARROW*/ || after.kind == 6/*TokenKind.LBRACE*/;
 }
 Parser.prototype._eatLeftParen = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
-  if (this._afterParensIndex < this._afterParens.length) {
+  if (this._afterParensIndex < this._afterParens.get$length()) {
     return this._afterParens.$index(this._afterParensIndex);
   }
   this._afterParensIndex = 0;
   this._afterParens.clear();
   var tokens = [this._next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
   this._next();
   return after;
 }
 Parser.prototype._lookaheadAfterParens = function(tokens) {
-  var saved = this._afterParens.length;
+  var saved = this._afterParens.get$length();
   this._afterParens.add(null);
   while (true) {
     var token = this._next();
     tokens.add(token);
     var kind = token.kind;
     if (kind == 3/*TokenKind.RPAREN*/ || kind == 1/*TokenKind.END_OF_FILE*/) {
       this._afterParens.$setindex(saved, this._peekToken);
       return;
     }
     else if (kind == 2/*TokenKind.LPAREN*/) {
@@ skipping 161 matching lines @@
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
   var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
   if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
     genericType.set$baseType(new TypeReference(span, $globals.world.listType));
     return this.finishListLiteral(start, isConst, genericType);
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     genericType.set$baseType(new TypeReference(span, $globals.world.mapType));
     var typeArgs = genericType.get$typeArguments();
-    if ($eq(typeArgs.length, 1)) {
+    if ($eq(typeArgs.get$length(), 1)) {
       genericType.set$typeArguments([new TypeReference(span, $globals.world.stringType), typeArgs.$index(0)]);
     }
-    else if ($eq(typeArgs.length, 2)) {
+    else if ($eq(typeArgs.get$length(), 2)) {
       var keyType = typeArgs.$index(0);
       if (!(keyType instanceof NameTypeReference) || $ne(keyType.get$name().get$name(), "String")) {
         $globals.world.error('the key type of a map literal is implicitly "String"', keyType.get$span());
       }
       else {
         $globals.world.warning('a map literal takes one type argument specifying the value type', keyType.get$span());
       }
     }
     return this.finishMapLiteral(start, isConst, genericType);
   }
@@ skipping 27 matching lines @@
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if (this._maybeEat(74/*TokenKind.EXTENDS*/)) {
     myType = this.type(1);
   }
   var tp = new TypeParameter(name, myType, this._makeSpan(start));
   return new ParameterType(name.get$name(), tp);
 }
 Parser.prototype.get$typeParameter = function() {
-  return Parser.prototype.typeParameter.bind(this);
+  return Parser.prototype.typeParameter.bind(this)
 }
 Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add$1(tp);
     if ((tp.get$typeParameter().get$extendsType() instanceof GenericTypeReference) && $eq(tp.get$typeParameter().get$extendsType().get$depth(), 0)) {
       closed = true;
       break;
     }
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   if (!closed) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
 Parser.prototype.get$typeParameters = function() {
-  return Parser.prototype.typeParameters.bind(this);
+  return Parser.prototype.typeParameters.bind(this)
 }
 Parser.prototype._eatClosingAngle = function(depth) {
   if (this._maybeEat(53/*TokenKind.GT*/)) {
     return depth;
   }
   else if (depth > 0 && this._maybeEat(40/*TokenKind.SAR*/)) {
     return depth - 1;
   }
   else if (depth > 1 && this._maybeEat(41/*TokenKind.SHR*/)) {
     return depth - 2;
@@ skipping 71 matching lines @@
 }
 Parser.prototype.type = function(depth) {
   var typeRef = this.nameTypeReference();
   if (this._peekKind(52/*TokenKind.LT*/)) {
     return this.addTypeArguments(typeRef, depth);
   }
   else {
     return typeRef;
   }
 }
+Parser.prototype.type.$optional = ['depth', '0']
 Parser.prototype.get$type = function() {
-  return Parser.prototype.type.bind(this);
+  return Parser.prototype.type.bind(this)
 }
 Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.get$type();
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
@@ skipping 97 matching lines @@
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
   this._pos = 0
   this.tokens = tokens;
   this.parser = parser;
   this.previousTokenizer = previousTokenizer;
   // Initializers done
 }
 DivertedTokenSource.prototype.next = function() {
   var token = this.tokens.$index(this._pos);
   ++this._pos;
-  if (this._pos == this.tokens.length) {
+  if (this._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;
   // Initializers done
 }
@@ skipping 973 matching lines @@
     while (args.hasNext$0() && params.hasNext$0()) {
       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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$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 16 matching lines @@
 Type.prototype._getMemberInParents = function(memberName) {
   if (this.get$isClass()) {
     if (this.get$parent() != null) {
       return this.get$parent().getMember(memberName);
     }
     else {
       return null;
     }
   }
   else {
-    if (this.get$interfaces() != null && this.get$interfaces().length > 0) {
+    if (this.get$interfaces() != null && this.get$interfaces().get$length() > 0) {
       var $$list = this.get$interfaces();
-      for (var $$i = 0;$$i < $$list.length; $$i++) {
+      for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
         var i = $$list.$index($$i);
         var ret = i.getMember$1(memberName);
         if (ret != null) {
           return ret;
         }
       }
     }
     return $globals.world.objectType.getMember(memberName);
   }
 }
@@ skipping 37 matching lines @@
       $globals.world.warning(msg, span);
     }
   }
 }
 Type.prototype.needsVarCall = function(args) {
   if (this.get$isVarOrFunction()) {
     return true;
   }
   var call = this.getCallMethod();
   if (call != null) {
-    if (args.get$length() != call.get$parameters().length || !call.namesInOrder$1(args)) {
+    if (args.get$length() != call.get$parameters().get$length() || !call.namesInOrder$1(args)) {
       return true;
     }
   }
   return false;
 }
 Type.union = function(x, y) {
   if ($eq(x, y)) return x;
   if (x.get$isNum() && y.get$isNum()) return $globals.world.numType;
   if (x.get$isString() && y.get$isString()) return $globals.world.stringType;
   return $globals.world.varType;
@@ skipping 24 matching lines @@
   }
   if ($eq(this, other)) return true;
   if (this.get$isVar()) return true;
   if (other.get$isVar()) return true;
   if (other._isDirectSupertypeOf(this)) return true;
   var call = this.getCallMethod();
   var otherCall = other.getCallMethod();
   if (call != null && otherCall != null) {
     return Type._isFunctionSubtypeOf(call, otherCall);
   }
-  if ($eq(this.get$genericType(), other.get$genericType()) && this.get$typeArgsInOrder() != null && other.get$typeArgsInOrder() != null && $eq(this.get$typeArgsInOrder().length, other.get$typeArgsInOrder().length)) {
+  if ($eq(this.get$genericType(), other.get$genericType()) && this.get$typeArgsInOrder() != null && other.get$typeArgsInOrder() != null && $eq(this.get$typeArgsInOrder().get$length(), other.get$typeArgsInOrder().get$length())) {
     var t = this.get$typeArgsInOrder().iterator$0();
     var s = other.get$typeArgsInOrder().iterator$0();
     while (t.hasNext$0()) {
       if (!t.next$0().isSubtypeOf$1(s.next$0())) return false;
     }
     return true;
   }
   if (this.get$parent() != null && this.get$parent().isSubtypeOf(other)) {
     return true;
   }
@@ skipping 12 matching lines @@
 }
 Type.prototype.$eq = function(other) {
   return (other instanceof Type) && $eq(other.get$name(), this.name) && $eq(this.get$library(), other.get$library());
 }
 Type._isFunctionSubtypeOf = function(t, s) {
   if (!s.returnType.get$isVoid() && !s.returnType.isAssignable(t.returnType)) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
-  if (tp.length < sp.length) return false;
+  if (tp.get$length() < sp.get$length()) return false;
   for (var i = 0;
-   i < sp.length; i++) {
+   i < sp.get$length(); i++) {
     if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
     if (tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name())) return false;
     if (!tp.$index(i).get$type().isAssignable$1(sp.$index(i).get$type())) return false;
   }
-  if (tp.length > sp.length && !tp.$index(sp.length).get$isOptional()) return false;
+  if (tp.get$length() > sp.get$length() && !tp.$index(sp.get$length()).get$isOptional()) return false;
   return true;
 }
 Type.prototype._checkExtends$0 = Type.prototype._checkExtends;
 Type.prototype.addDirectSubtype$1 = Type.prototype.addDirectSubtype;
 Type.prototype.ensureSubtypeOf$3 = Type.prototype.ensureSubtypeOf;
 Type.prototype.getConstructor$1 = Type.prototype.getConstructor;
 Type.prototype.getFactory$2 = Type.prototype.getFactory;
 Type.prototype.getMember$1 = Type.prototype.getMember;
 Type.prototype.getOrMakeConcreteType$1 = Type.prototype.getOrMakeConcreteType;
 Type.prototype.hashCode$0 = Type.prototype.hashCode;
@@ skipping 217 matching lines @@
 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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$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();
@@ skipping 135 matching lines @@
     this._concreteTypes = new HashMapImplementation();
     this.typeParameters = this.definition.get$typeParameters();
   }
 }
 DefinedType.prototype.get$nativeType = function() {
   return (this.definition != null ? this.definition.get$nativeType() : null);
 }
 DefinedType.prototype.get$typeArgsInOrder = function() {
   if (this.typeParameters == null) return null;
   if (this._typeArgsInOrder == null) {
-    this._typeArgsInOrder = new FixedCollection_Type($globals.world.varType, this.typeParameters.length);
+    this._typeArgsInOrder = new FixedCollection_Type($globals.world.varType, this.typeParameters.get$length());
   }
   return this._typeArgsInOrder;
 }
 DefinedType.prototype.get$isVar = function() {
   return $eq(this, $globals.world.varType);
 }
 DefinedType.prototype.get$isVoid = function() {
   return $eq(this, $globals.world.voidType);
 }
 DefinedType.prototype.get$isTop = function() {
@@ skipping 36 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.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$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.length; $$i++) {
+  for (var $$i = 0;$$i < types.get$length(); $$i++) {
     var type = types.$index($$i);
     var resolvedInterface = this.resolveType(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;
 }
@@ skipping 42 matching lines @@
     if (ancestor.get$interfaces() != null) {
       var $$list = ancestor.get$interfaces();
       for (var $$i = ancestor.get$interfaces().iterator$0(); $$i.hasNext$0(); ) {
         var parent = $$i.next$0();
         if (_helper(parent)) return true;
       }
     }
     return false;
   }
   for (var i = 0;
-   i < this.interfaces.length; i++) {
+   i < this.interfaces.get$length(); 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.length > 0) {
-        if (typeDef.extendsTypes.length > 1) {
+      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.$index(1).get$span());
         }
         var extendsTypeRef = typeDef.extendsTypes.$index(0);
         if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = extendsTypeRef;
           this.set$parent(this.resolveType(g.baseType, true));
         }
         this.set$parent(this.resolveType(extendsTypeRef, true));
         if (!this.get$parent().get$isClass()) {
           $globals.world.error('class may not extend an interface - use implements', typeDef.extendsTypes.$index(0).get$span());
         }
         this.get$parent().addDirectSubtype(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(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if (typeDef.factoryType != null) {
         $globals.world.error('factory not allowed on classes', typeDef.factoryType.span);
       }
     }
     else {
-      if (typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0) {
+      if (typeDef.implementsTypes != null && typeDef.implementsTypes.get$length() > 0) {
         $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.$index(res).get$span());
       }
       if (typeDef.factoryType != null) {
         this.factory_ = this.resolveType(typeDef.factoryType, true);
         if (this.factory_ == null) {
           $globals.world.warning('unresolved factory', typeDef.factoryType.span);
         }
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [$globals.world.functionType];
   }
   if (this.typeParameters != null) {
     var $$list = this.typeParameters;
-    for (var $$i = 0;$$i < $$list.length; $$i++) {
+    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var tp = $$list.$index($$i);
       tp.set$enclosingElement(this);
       tp.resolve$0();
     }
   }
   if (this.get$isObject()) this._createNotEqualMember();
   $globals.world._addType(this);
   var $$list = this.constructors.getValues();
   for (var $$i = this.constructors.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var c = $$i.next$0();
@@ skipping 20 matching lines @@
   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.length == 1 && $eq(definition.modifiers.$index(0).get$kind(), 75/*TokenKind.FACTORY*/)) {
+  if (definition.modifiers != null && definition.modifiers.get$length() == 1 && $eq(definition.modifiers.$index(0).get$kind(), 75/*TokenKind.FACTORY*/)) {
     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 20 matching lines @@
     return;
   }
   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.length; i++) {
+   i < definition.names.get$length(); i++) {
     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.$index(i);
     }
     var field = new FieldMember(name, this, definition, value);
@@ skipping 59 matching lines @@
   return this._getMemberInParents(memberName);
 }
 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.length; i++) {
+   i < typeArgs.get$length(); i++) {
     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) {
@@ skipping 49 matching lines @@
 }
 NativeType.prototype.get$name = function() { return this.name; };
 NativeType.prototype.set$name = function(value) { return this.name = value; };
 // ********** Code for FixedCollection **************
 function FixedCollection(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
 FixedCollection.prototype.get$value = function() { return this.value; };
+FixedCollection.prototype.get$length = function() { return this.length; };
 FixedCollection.prototype.iterator = function() {
   return new FixedIterator_E(this.value, this.length);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new ListFactory(), f);
 }
 FixedCollection.prototype.every = function(f) {
@@ skipping 27 matching lines @@
   // Initializers done
 }
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
 FixedIterator.prototype.get$value = function() { return this.value; };
+FixedIterator.prototype.get$length = function() { return this.length; };
 FixedIterator.prototype.hasNext = function() {
   return this._index < this.length;
 }
 FixedIterator.prototype.next = function() {
   this._index++;
   return this.value;
 }
 FixedIterator.prototype.hasNext$0 = FixedIterator.prototype.hasNext;
 FixedIterator.prototype.next$0 = FixedIterator.prototype.next;
 // ********** Code for FixedIterator_E **************
@@ skipping 104 matching lines @@
   var member = this._resolveMember(context, name, null, true);
   return member != null && member.canInvoke$2(context, args);
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
   if (this.isSuper) {
     var m = this.get$type().getMember('noSuchMethod');
     return m != null && !m.get$declaringType().get$isObject();
   }
   else {
     var m = this.get$type().resolveMember('noSuchMethod');
-    return m != null && m.get$members().length > 1;
+    return m != null && m.get$members().get$length() > 1;
   }
 }
 Value.prototype._tryResolveMember = function(context, name) {
   if (this.isSuper) {
     return this.get$type().getMember(name);
   }
   else {
     return this.get$type().resolveMember(name);
   }
 }
@@ skipping 35 matching lines @@
     $globals.world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = $globals.world.functionType.getCallStub(args);
   return new Value($globals.world.varType, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), this.span, true);
 }
 Value.prototype.needsConversion = function(toType) {
   var callMethod = toType.getCallMethod();
   if (callMethod != null) {
-    var arity = callMethod.get$parameters().length;
+    var arity = callMethod.get$parameters().get$length();
     var myCall = this.get$type().getCallMethod();
-    if (myCall == null || $ne(myCall.get$parameters().length, arity)) {
+    if (myCall == null || $ne(myCall.get$parameters().get$length(), arity)) {
       return true;
     }
   }
   if ($globals.options.enableTypeChecks) {
     var fromType = this.get$type();
     if (this.get$type().get$isVar() && (this.code != 'null' || !toType.get$isNullable())) {
       fromType = $globals.world.objectType;
     }
     var bothNum = this.get$type().get$isNum() && toType.get$isNum();
     return !(fromType.isSubtypeOf(toType) || bothNum);
   }
   return false;
 }
 Value.prototype.convertTo = function(context, toType, node, isDynamic) {
   var checked = !isDynamic;
   var callMethod = toType.getCallMethod();
   if (callMethod != null) {
     if (checked && !toType.isAssignable(this.get$type())) {
       this.convertWarning(toType, node);
     }
-    var arity = callMethod.get$parameters().length;
+    var arity = callMethod.get$parameters().get$length();
     var myCall = this.get$type().getCallMethod();
-    if (myCall == null || $ne(myCall.get$parameters().length, arity)) {
+    if (myCall == null || $ne(myCall.get$parameters().get$length(), arity)) {
       var stub = $globals.world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       var val = new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), node.span, true);
       return this._isDomCallback(toType) && !this._isDomCallback(this.get$type()) ? val._wrapDomCallback$2(toType, arity) : val;
     }
     else if (this._isDomCallback(toType) && !this._isDomCallback(this.get$type())) {
       return this._wrapDomCallback(toType, arity);
     }
   }
   var fromType = this.get$type();
   if (this.get$type().get$isVar() && (this.code != 'null' || !toType.get$isNullable())) {
@@ skipping 198 matching lines @@
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   // Initializers done
   EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
   var values = new HashMapImplementation();
   for (var i = 0;
-   i < keyValuePairs.length; i += 2) {
+   i < keyValuePairs.get$length(); i += 2) {
     values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 ConstMapValue.prototype.get$values = function() { return this.values; };
 ConstMapValue.prototype.set$values = function(value) { return this.values = value; };
 // ********** Code for ConstObjectValue **************
 $inherits(ConstObjectValue, EvaluatedValue);
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
@@ skipping 21 matching lines @@
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
 function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, span, _dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.dependencies = [];
   // Initializers done
   Value.call(this, type, code, span, !isConst);
-  for (var $$i = 0;$$i < _dependencies.length; $$i++) {
+  for (var $$i = 0;$$i < _dependencies.get$length(); $$i++) {
     var dep = _dependencies.$index($$i);
     this.dependencies.add(dep);
     this.dependencies.addAll(dep.get$dependencies());
   }
 }
 GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
   var code = (exp.get$isConst() ? exp.get$canonicalCode() : exp.code);
   var codeWithComment = ('' + code + '/*' + field.get$declaringType().get$name() + '.' + field.get$name() + '*/');
   return new GlobalValue(exp.get$type(), codeWithComment, field.get$isFinal(), field, null, exp, code, exp.span, dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
@@ skipping 27 matching lines @@
 GlobalValue.prototype.compareTo = function(other) {
   if ($eq(other, this)) {
     return 0;
   }
   else if (this.dependencies.indexOf(other) >= 0) {
     return 1;
   }
   else if (other.dependencies.indexOf(this) >= 0) {
     return -1;
   }
-  else if (this.dependencies.length > other.dependencies.length) {
+  else if (this.dependencies.get$length() > other.dependencies.get$length()) {
     return 1;
   }
-  else if (this.dependencies.length < other.dependencies.length) {
+  else if (this.dependencies.get$length() < other.dependencies.get$length()) {
     return -1;
   }
   else if (this.name == null && other.name != null) {
     return 1;
   }
   else if (this.name != null && other.name == null) {
     return -1;
   }
   else if (this.name != null) {
     return this.name.compareTo(other.name);
@@ skipping 248 matching lines @@
     })
     )) {
       library.imports.add(new LibraryImport(this.corelib));
     }
     this.libraries.$setindex(filename, library);
     this._todo.add(library);
   }
   return library;
 }
 World.prototype.process = function() {
-  while (this._todo.length > 0) {
+  while (this._todo.get$length() > 0) {
     var todo = this._todo;
     this._todo = [];
-    for (var $$i = 0;$$i < todo.length; $$i++) {
+    for (var $$i = 0;$$i < todo.get$length(); $$i++) {
       var lib = todo.$index($$i);
       lib.visitSources$0();
     }
   }
 }
 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();
   for (var $$i = this.libraries.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.resolve$0();
   }
 }
 World.prototype.get$resolveAll = function() {
-  return World.prototype.resolveAll.bind(this);
+  return World.prototype.resolveAll.bind(this)
 }
 World.prototype.generateCode = function(lib) {
   var mainMembers = lib.topType.resolveMember('main');
   var main = null;
-  if (mainMembers == null || $eq(mainMembers.get$members().length, 0)) {
+  if (mainMembers == null || $eq(mainMembers.get$members().get$length(), 0)) {
     this.fatal('no main method specified');
   }
-  else if (mainMembers.get$members().length > 1) {
+  else if (mainMembers.get$members().get$length() > 1) {
     var $$list = mainMembers.get$members();
     for (var $$i = mainMembers.get$members().iterator$0(); $$i.hasNext$0(); ) {
       var m = $$i.next$0();
       main = m;
       this.error('more than one main member (using last?)', main.get$span());
     }
   }
   else {
     main = mainMembers.get$members().$index(0);
   }
   var codeWriter = new CodeWriter();
   this.gen = new WorldGenerator(main, codeWriter);
   this.gen.run();
-  this.jsBytesWritten = codeWriter.get$text().length;
+  this.jsBytesWritten = codeWriter.get$text().get$length();
 }
 World.prototype._message = function(color, prefix, message, span, span1, span2, throwing) {
   if (this.messageHandler != null) {
     this.messageHandler(prefix, message, span);
     if (span1 != null) {
       this.messageHandler(prefix, message, span1);
     }
     if (span2 != null) {
       this.messageHandler(prefix, message, span2);
     }
@@ skipping 103 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.length; i++) {
+   i < args.get$length(); i++) {
     var arg = args.$index(i);
     switch (arg) {
       case '--enable_leg':
 
         this.enableLeg = true;
         break;
 
       case '--leg_only':
 
         this.enableLeg = true;
@@ skipping 68 matching lines @@
 
       case '--no_colors':
 
         this.useColors = false;
         break;
 
       default:
 
         if (arg.endsWith$1('.dart')) {
           this.dartScript = arg;
-          this.childArgs = args.getRange(i + 1, args.length - i - 1);
+          this.childArgs = args.getRange(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 137 matching lines @@
     code.exitBlock('};');
   }
 }
 VarMethodStub.prototype._needsExactTypeCheck = function() {
   var $this = this; // closure support
   if (this.member == null || this.member.declaringType.get$isObject()) return false;
   var members = this.member.declaringType.resolveMember(this.member.name).members;
   return members.filter$1((function (m) {
     return $ne(m, $this.member) && m.get$declaringType().get$isHiddenNativeType();
   })
-  ).length >= 1;
+  ).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.length; i++) {
+     i < method.parameters.get$length(); i++) {
       if ($ne(method.parameters.$index(i).get$value().get$code(), 'null')) {
         return false;
       }
     }
     return method.namesInOrder(args);
   }
   else {
     return false;
   }
 }
@@ skipping 13 matching lines @@
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 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.length; $$i++) {
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var member = $$list.$index($$i);
     var type = member.get$declaringType();
     var target = new Value(type, 'this', node.span, true);
     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, true);
     var result = target.invokeNoSuchMethod(context, this.baseName, node, this.args);
     var stub = new VarMethodStub(this.name, null, this.args, 'return ' + result.get$code());
     $globals.world.objectType.varStubs.$setindex(stub.get$name(), stub);
   }
 }
 VarMethodSet.prototype.generate = function(code) {
 
 }
 VarMethodSet.prototype.generate$1 = VarMethodSet.prototype.generate;
 VarMethodSet.prototype.invoke$4 = VarMethodSet.prototype.invoke;
 // ********** Code for top level **************
 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 ListFactory();
   if (!!(source && source.is$List())) {
     var list = source;
-    result.length = list.length;
+    result.set$length(list.get$length());
     for (var i = 0;
-     i < list.length; i++) {
+     i < list.get$length(); i++) {
       result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
     for (var $$i = source.iterator(); $$i.hasNext$0(); ) {
       var item = $$i.next$0();
       result.add(mapper(item));
     }
   }
   return result;
 }
 function reduce(source, callback, initialValue) {
   var i = source.iterator();
   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();
   keys.sort((function (x, y) {
     return x.compareTo$1(y);
   })
   );
   var values = [];
-  for (var $$i = 0;$$i < keys.length; $$i++) {
+  for (var $$i = 0;$$i < keys.get$length(); $$i++) {
     var k = keys.$index($$i);
     values.add(map.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
   return text.startsWith('"""') || text.startsWith("'''");
 }
 function isRawMultilineString(text) {
   return text.startsWith('@"""') || text.startsWith("@'''");
@@ skipping 73 matching lines @@
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }
 //  ********** Library minfrog **************
 // ********** Code for top level **************
 function main() {
   var homedir = path.dirname(fs.realpathSync(process.argv.$index(1)));
   var argv = [];
   for (var i = 0;
-   i < process.argv.length; i++) {
+   i < process.argv.get$length(); i++) {
     argv.add$1(process.argv.$index(i));
     if (i == 1) {
       var terminal = 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();
@@ skipping 33 matching lines @@
   $globals._NO_COLOR = '\u001b[0m';
   $globals._RED_COLOR = '\u001b[31m';
 }
 var const$0 = new EnvMap()/*const EnvMap()*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var const$8 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var $globals = {};
 $static_init();
 main();