Modification to the order that classes are printed out so that the prototype

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 106 matching lines @@
 }
 function $truncdiv(x, y) {
   if (typeof(x) == 'number' && typeof(y) == 'number') {
     if (y == 0) $throw(new IntegerDivisionByZeroException());
     var tmp = x / y;
     return (tmp < 0) ? Math.ceil(tmp) : Math.floor(tmp);
   } else {
     return x.$truncdiv(y);
   }
 }
-// ********** Code for Clock **************
-function Clock() {}
-Clock.now = function() {
-  return new Date().getTime();
-}
-Clock.frequency = function() {
-  return 1000;
-}
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
 Object.prototype._checkExtends$0 = function() {
   return this.noSuchMethod("_checkExtends", []);
 };
@@ skipping 233 matching lines @@
 };
 Object.prototype.visitPostfixExpression$1 = function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
 };
 Object.prototype.visitSources$0 = function() {
   return this.noSuchMethod("visitSources", []);
 };
 Object.prototype.writeDefinition$2 = function($0, $1) {
   return this.noSuchMethod("writeDefinition", [$0, $1]);
 };
+// ********** Code for Clock **************
+function Clock() {}
+Clock.now = function() {
+  return new Date().getTime();
+}
+Clock.frequency = function() {
+  return 1000;
+}
 // ********** 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;
@@ skipping 243 matching lines @@
 ListFactory.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 ListFactory_E = ListFactory;
 ListFactory_K = ListFactory;
 ListFactory_String = ListFactory;
 ListFactory_V = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
-  this._dart_coreimpl_pos = 0;
+  this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
-  return this._array.length > this._dart_coreimpl_pos;
+  return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
-  return this._array.$index(this._dart_coreimpl_pos++);
+  return this._array.$index(this._pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.isNaN = function() {
   return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   return this == 0 ? (1 / this) < 0 : this < 0;
@@ skipping 203 matching lines @@
   return (this._probeForLookup(key) != -1);
 }
 HashMapImplementation.prototype.containsKey$1 = HashMapImplementation.prototype.containsKey;
 HashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 HashMapImplementation.prototype.getKeys$0 = HashMapImplementation.prototype.getKeys;
 HashMapImplementation.prototype.getValues$0 = HashMapImplementation.prototype.getValues;
 HashMapImplementation.prototype.isEmpty$0 = HashMapImplementation.prototype.isEmpty;
 // ********** Code for HashMapImplementation_E$E **************
-function HashMapImplementation_E$E() {
-  // Initializers done
-  this._numberOfEntries = 0;
-  this._numberOfDeleted = 0;
-  this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-}
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }
 $inherits(HashMapImplementation_E$E, HashMapImplementation);
+function HashMapImplementation_E$E() {
+  // Initializers done
+  this._numberOfEntries = 0;
+  this._numberOfDeleted = 0;
+  this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+}
 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) {
@@ skipping 102 matching lines @@
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation_E$E.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 // ********** Code for HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V **************
+$inherits(HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V, HashMapImplementation);
 function HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V() {}
-$inherits(HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V, HashMapImplementation);
 // ********** Code for HashMapImplementation_String$EvaluatedValue **************
+$inherits(HashMapImplementation_String$EvaluatedValue, HashMapImplementation);
 function HashMapImplementation_String$EvaluatedValue() {}
-$inherits(HashMapImplementation_String$EvaluatedValue, HashMapImplementation);
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation_E$E();
 }
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation();
   for (var $$i = other.iterator(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     set.add(e);
@@ skipping 63 matching lines @@
 };
 HashSetImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 HashSetImplementation.prototype.isEmpty$0 = HashSetImplementation.prototype.isEmpty;
 HashSetImplementation.prototype.iterator$0 = HashSetImplementation.prototype.iterator;
 HashSetImplementation.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for HashSetImplementation_E **************
+$inherits(HashSetImplementation_E, HashSetImplementation);
 function HashSetImplementation_E() {}
-$inherits(HashSetImplementation_E, HashSetImplementation);
 // ********** Code for HashSetImplementation_String **************
+$inherits(HashSetImplementation_String, HashSetImplementation);
 function HashSetImplementation_String() {}
-$inherits(HashSetImplementation_String, HashSetImplementation);
 // ********** Code for HashSetImplementation_Type **************
+$inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
-$inherits(HashSetImplementation_Type, HashSetImplementation);
 // ********** 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._entries.$index(this._nextValidIndex) === const$3/*HashMapImplementation._DELETED_KEY*/) {
@@ skipping 15 matching lines @@
   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();
 }
-$inherits(HashSetIterator_E, HashSetIterator);
 HashSetIterator_E.prototype._advance = function() {
   var length = this._entries.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() {
   // Initializers done
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
 KeyValuePair.prototype.get$value = function() { return this.value; };
 KeyValuePair.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for KeyValuePair_K$V **************
+$inherits(KeyValuePair_K$V, KeyValuePair);
 function KeyValuePair_K$V(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
-$inherits(KeyValuePair_K$V, KeyValuePair);
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   // Initializers done
   this._map = new HashMapImplementation();
   this._list = new DoubleLinkedQueue_KeyValuePair_K$V();
 }
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
   if (this._map.containsKey(key)) {
     this._map.$index(key).get$element().set$value(value);
   }
@@ skipping 74 matching lines @@
 DoubleLinkedQueueEntry.prototype._asNonSentinelEntry = function() {
   return this;
 }
 DoubleLinkedQueueEntry.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 DoubleLinkedQueueEntry.prototype.get$element = function() {
   return this._element;
 }
 // ********** Code for DoubleLinkedQueueEntry_E **************
+$inherits(DoubleLinkedQueueEntry_E, DoubleLinkedQueueEntry);
 function DoubleLinkedQueueEntry_E(e) {
   // Initializers done
   this._element = e;
 }
-$inherits(DoubleLinkedQueueEntry_E, DoubleLinkedQueueEntry);
 DoubleLinkedQueueEntry_E.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 DoubleLinkedQueueEntry_E.prototype.prepend = function(e) {
   new DoubleLinkedQueueEntry_E(e)._link(this._previous, this);
 }
 DoubleLinkedQueueEntry_E.prototype.remove = function() {
   this._previous._next = this._next;
   this._next._previous = this._previous;
   this._next = null;
   this._previous = null;
   return this._element;
 }
 DoubleLinkedQueueEntry_E.prototype._asNonSentinelEntry = function() {
   return this;
 }
 DoubleLinkedQueueEntry_E.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 // ********** Code for DoubleLinkedQueueEntry_KeyValuePair_K$V **************
+$inherits(DoubleLinkedQueueEntry_KeyValuePair_K$V, DoubleLinkedQueueEntry);
 function DoubleLinkedQueueEntry_KeyValuePair_K$V(e) {
   // Initializers done
   this._element = e;
 }
-$inherits(DoubleLinkedQueueEntry_KeyValuePair_K$V, DoubleLinkedQueueEntry);
 DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.prepend = function(e) {
   new DoubleLinkedQueueEntry_KeyValuePair_K$V(e)._link(this._previous, this);
 }
 DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype._asNonSentinelEntry = function() {
   return this;
 }
 DoubleLinkedQueueEntry_KeyValuePair_K$V.prototype.previousEntry = function() {
   return this._previous._asNonSentinelEntry();
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
+$inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry_E);
 function _DoubleLinkedQueueEntrySentinel() {
   // Initializers done
   DoubleLinkedQueueEntry_E.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry_E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
   $throw(const$2/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
   $throw(const$2/*const EmptyQueueException()*/);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel_E **************
+$inherits(_DoubleLinkedQueueEntrySentinel_E, _DoubleLinkedQueueEntrySentinel);
 function _DoubleLinkedQueueEntrySentinel_E() {
   // Initializers done
   DoubleLinkedQueueEntry_E.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel_E, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V **************
+$inherits(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, _DoubleLinkedQueueEntrySentinel);
 function _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V() {
   // Initializers done
   DoubleLinkedQueueEntry_KeyValuePair_K$V.call(this, null);
   this._link(this, this);
 }
-$inherits(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, _DoubleLinkedQueueEntrySentinel);
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_E();
 }
 DoubleLinkedQueue.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue.prototype.add = function(value) {
   this.addLast(value);
@@ skipping 78 matching lines @@
   return this.forEach(to$call$1($0));
 };
 DoubleLinkedQueue.prototype.isEmpty$0 = DoubleLinkedQueue.prototype.isEmpty;
 DoubleLinkedQueue.prototype.iterator$0 = DoubleLinkedQueue.prototype.iterator;
 DoubleLinkedQueue.prototype.last$0 = DoubleLinkedQueue.prototype.last;
 DoubleLinkedQueue.prototype.removeLast$0 = DoubleLinkedQueue.prototype.removeLast;
 DoubleLinkedQueue.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for DoubleLinkedQueue_E **************
+$inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
 function DoubleLinkedQueue_E() {}
-$inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
 // ********** Code for DoubleLinkedQueue_KeyValuePair_K$V **************
+$inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
 function DoubleLinkedQueue_KeyValuePair_K$V() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V();
 }
-$inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
     var nextEntry = entry._next;
@@ skipping 13 matching lines @@
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 _DoubleLinkedQueueIterator.prototype.hasNext$0 = _DoubleLinkedQueueIterator.prototype.hasNext;
 _DoubleLinkedQueueIterator.prototype.next$0 = _DoubleLinkedQueueIterator.prototype.next;
 // ********** Code for _DoubleLinkedQueueIterator_E **************
+$inherits(_DoubleLinkedQueueIterator_E, _DoubleLinkedQueueIterator);
 function _DoubleLinkedQueueIterator_E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
-$inherits(_DoubleLinkedQueueIterator_E, _DoubleLinkedQueueIterator);
 // ********** Code for StopwatchImplementation **************
 function StopwatchImplementation() {
   this._start = null;
   this._stop = null;
   // Initializers done
 }
 StopwatchImplementation.prototype.start = function() {
   if (this._start == null) {
     this._start = Clock.now();
   }
@@ skipping 710 matching lines @@
     if (!isSubtype) {
       body = $globals.world.objectType.varStubs.$index(checkName).get$body();
     }
     else if (onType.name == 'StringImplementation' || onType.name == 'NumImplementation') {
       body = ('return ' + onType.get$nativeType().name + '(this)');
     }
     this.writer.writeln(this._prototypeOf(onType, checkName) + (' = function(){' + body + '};'));
   }
 }
 WorldGenerator.prototype.writeType = function(type) {
+  if (type.isWritten) return;
+  type.isWritten = true;
+  if (type.get$parent() != null && !type.get$isNative()) {
+    this.writeType(type.get$parent());
+  }
   if (type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), $globals.world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
     this.writer.writeln(('' + type.get$jsname() + ' = ' + type.get$genericType().get$jsname() + ';'));
     return;
   }
   var typeName = type.get$jsname() != null ? type.get$jsname() : 'top level';
   this.writer.comment(('// ********** Code for ' + typeName + ' **************'));
   if (type.get$isNative() && !type.get$isTop()) {
     var nativeName = type.get$definition().get$nativeType().get$name();
     if ($eq(nativeName, '')) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
     else if (type.get$jsname() != nativeName) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
+  if (!type.get$isTop()) {
+    if ((type instanceof ConcreteType)) {
+      var c = type;
+      this.corejs.ensureInheritsHelper();
+      this.writer.writeln(('\$inherits(' + c.get$jsname() + ', ' + c.genericType.get$jsname() + ');'));
+      for (var p = c._parent;
+       (p instanceof ConcreteType); p = p.get$_parent()) {
+        this._ensureInheritMembersHelper();
+        this._mixins.writeln(('\$inheritsMembers(' + c.get$jsname() + ', ' + p.get$jsname() + ');'));
+      }
+    }
+    else if (!type.get$isNative()) {
+      if (type.get$parent() != null && !type.get$parent().get$isObject()) {
+        this.corejs.ensureInheritsHelper();
+        this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
+      }
+    }
+  }
   if (type.get$isTop()) {
   }
   else if (type.get$constructors().get$length() == 0) {
     if (!type.get$isNative()) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
     var standardConstructor = type.get$constructors().$index('');
     if (standardConstructor == null || standardConstructor.generator == null) {
       if (!type.get$isNative()) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
     var $$list = type.get$constructors().getValues();
     for (var $$i = type.get$constructors().getValues().iterator$0(); $$i.hasNext$0(); ) {
       var c = $$i.next$0();
       if (c.get$generator() != null && $ne(c, standardConstructor)) {
         c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
-  if (!type.get$isTop()) {
-    if ((type instanceof ConcreteType)) {
-      var c = type;
-      this.corejs.ensureInheritsHelper();
-      this.writer.writeln(('\$inherits(' + c.get$jsname() + ', ' + c.genericType.get$jsname() + ');'));
-      for (var p = c._parent;
-       (p instanceof ConcreteType); p = p.get$_parent()) {
-        this._ensureInheritMembersHelper();
-        this._mixins.writeln(('\$inheritsMembers(' + c.get$jsname() + ', ' + p.get$jsname() + ');'));
-      }
-    }
-    else if (!type.get$isNative()) {
-      if (type.get$parent() != null && !type.get$parent().get$isObject()) {
-        this.corejs.ensureInheritsHelper();
-        this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
-      }
-    }
-  }
   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++) {
       var ct = $$list.$index($$i);
       this._maybeIsTest(type, ct);
     }
   }
@@ skipping 1748 matching lines @@
 function LibraryImport(library, prefix) {
   this.library = library;
   this.prefix = prefix;
   // Initializers done
 }
 LibraryImport.prototype.get$prefix = function() { return this.prefix; };
 LibraryImport.prototype.set$prefix = function(value) { return this.prefix = value; };
 LibraryImport.prototype.get$library = function() { return this.library; };
 LibraryImport.prototype.set$library = function(value) { return this.library = value; };
 // ********** Code for Library **************
+$inherits(Library, Element);
 function Library(baseSource) {
   this.isWritten = false
   this.isMarked = false
   this.baseSource = baseSource;
   // Initializers done
   Element.call(this, null, null);
   this.sourceDir = dirname(this.baseSource.filename);
   this.topType = new DefinedType(null, this, null, true);
   this.types = _map(['', this.topType]);
   this.imports = [];
   this.natives = [];
   this.sources = [];
   this._privateMembers = new HashMapImplementation();
 }
-$inherits(Library, Element);
 Library.prototype.get$baseSource = function() { return this.baseSource; };
 Library.prototype.get$types = function() { return this.types; };
 Library.prototype.set$types = function(value) { return this.types = value; };
 Library.prototype.get$_privateMembers = function() { return this._privateMembers; };
 Library.prototype.set$_privateMembers = function(value) { return this._privateMembers = value; };
 Library.prototype.get$topType = function() { return this.topType; };
 Library.prototype.set$topType = function(value) { return this.topType = value; };
 Library.prototype.get$enclosingElement = function() {
   return null;
 }
@@ skipping 476 matching lines @@
 Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
 Parameter.prototype.get$hasDefaultValue = function() {
   return !(this.definition.value instanceof NullExpression) || (this.definition.value.span.start != this.definition.span.start);
 }
 Parameter.prototype.copyWithNewType$2 = Parameter.prototype.copyWithNewType;
 Parameter.prototype.genValue$2 = Parameter.prototype.genValue;
 Parameter.prototype.resolve$0 = Parameter.prototype.resolve;
 // ********** Code for Member **************
+$inherits(Member, Element);
 function Member(name, declaringType) {
   this.isGenerated = false;
   this.declaringType = declaringType;
   // Initializers done
   Element.call(this, name, declaringType);
 }
-$inherits(Member, Element);
 Member.prototype.get$declaringType = function() { return this.declaringType; };
 Member.prototype.get$generator = function() { return this.generator; };
 Member.prototype.set$generator = function(value) { return this.generator = value; };
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
   return this.name.startsWith('_');
 }
 Member.prototype.get$isConstructor = function() {
@@ skipping 111 matching lines @@
 Member.prototype.computeValue$0 = Member.prototype.computeValue;
 Member.prototype.hashCode$0 = Member.prototype.hashCode;
 Member.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 Member.prototype.invoke$4$isDynamic = Member.prototype.invoke;
 Member.prototype.invoke$5 = Member.prototype.invoke;
 Member.prototype.provideFieldSyntax$0 = Member.prototype.provideFieldSyntax;
 Member.prototype.providePropertySyntax$0 = Member.prototype.providePropertySyntax;
 // ********** Code for TypeMember **************
+$inherits(TypeMember, Member);
 function TypeMember(type) {
   this.type = type;
   // Initializers done
   Member.call(this, type.name, type.library.topType);
 }
-$inherits(TypeMember, Member);
 TypeMember.prototype.get$type = function() { return this.type; };
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
   return $globals.world.varType;
 }
@@ skipping 28 matching lines @@
 };
 TypeMember.prototype._set$4$isDynamic = TypeMember.prototype._set;
 TypeMember.prototype._set$5 = TypeMember.prototype._set;
 TypeMember.prototype.canInvoke$2 = TypeMember.prototype.canInvoke;
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 TypeMember.prototype.invoke$4$isDynamic = TypeMember.prototype.invoke;
 TypeMember.prototype.invoke$5 = TypeMember.prototype.invoke;
 // ********** Code for FieldMember **************
+$inherits(FieldMember, Member);
 function FieldMember(name, declaringType, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   // Initializers done
   Member.call(this, name, declaringType);
 }
-$inherits(FieldMember, Member);
 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; };
@@ skipping 153 matching lines @@
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
 FieldMember.prototype._set$4$isDynamic = FieldMember.prototype._set;
 FieldMember.prototype._set$5 = FieldMember.prototype._set;
 FieldMember.prototype.computeValue$0 = FieldMember.prototype.computeValue;
 FieldMember.prototype.provideFieldSyntax$0 = FieldMember.prototype.provideFieldSyntax;
 FieldMember.prototype.providePropertySyntax$0 = FieldMember.prototype.providePropertySyntax;
 FieldMember.prototype.resolve$0 = FieldMember.prototype.resolve;
 // ********** Code for PropertyMember **************
+$inherits(PropertyMember, Member);
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   // Initializers done
   Member.call(this, name, declaringType);
 }
-$inherits(PropertyMember, Member);
 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$span = function() {
   return this.getter != null ? this.getter.get$span() : null;
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
@@ skipping 85 matching lines @@
 PropertyMember.prototype._get$4 = PropertyMember.prototype._get;
 PropertyMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
 PropertyMember.prototype._set$4$isDynamic = PropertyMember.prototype._set;
 PropertyMember.prototype._set$5 = PropertyMember.prototype._set;
 PropertyMember.prototype.provideFieldSyntax$0 = PropertyMember.prototype.provideFieldSyntax;
 PropertyMember.prototype.providePropertySyntax$0 = PropertyMember.prototype.providePropertySyntax;
 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++) {
     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);
     }
   }
 }
-$inherits(ConcreteMember, Member);
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
 ConcreteMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 ConcreteMember.prototype.get$parameters = function() { return this.parameters; };
 ConcreteMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 ConcreteMember.prototype.get$span = function() {
   return this.baseMember.get$span();
 }
 ConcreteMember.prototype.get$isStatic = function() {
   return this.baseMember.get$isStatic();
 }
@@ skipping 102 matching lines @@
 ConcreteMember.prototype.canInvoke$2 = ConcreteMember.prototype.canInvoke;
 ConcreteMember.prototype.computeValue$0 = ConcreteMember.prototype.computeValue;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 ConcreteMember.prototype.invoke$4$isDynamic = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.invoke$5 = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.provideFieldSyntax$0 = ConcreteMember.prototype.provideFieldSyntax;
 ConcreteMember.prototype.providePropertySyntax$0 = ConcreteMember.prototype.providePropertySyntax;
 // ********** Code for MethodMember **************
+$inherits(MethodMember, Member);
 function MethodMember(name, declaringType, definition) {
   this.isStatic = false
   this.isAbstract = false
   this.isConst = false
   this.isFactory = false
   this.isLambda = false
   this._providePropertySyntax = false
   this._provideFieldSyntax = false
   this._provideOptionalParamInfo = false
   this.definition = definition;
   // Initializers done
   Member.call(this, name, declaringType);
 }
-$inherits(MethodMember, Member);
 MethodMember.prototype.get$definition = function() { return this.definition; };
 MethodMember.prototype.set$definition = function(value) { return this.definition = value; };
 MethodMember.prototype.get$returnType = function() { return this.returnType; };
 MethodMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 MethodMember.prototype.get$parameters = function() { return this.parameters; };
 MethodMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 MethodMember.prototype.get$typeParameters = function() { return this.typeParameters; };
 MethodMember.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
@@ skipping 1033 matching lines @@
   return new SourceSpan(this.source, this.start, this.end);
 }
 Token.prototype.end$0 = function() {
   return this.end();
 };
 Token.prototype.start$0 = function() {
   return this.start();
 };
 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);
 }
-$inherits(ErrorToken, Token);
 ErrorToken.prototype.get$message = function() { return this.message; };
 ErrorToken.prototype.set$message = function(value) { return this.message = value; };
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.get$filename = function() { return this.filename; };
 SourceFile.prototype.get$orderInLibrary = function() { return this.orderInLibrary; };
@@ skipping 126 matching lines @@
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
   if (stack != null) newStack.set$previous(stack);
   return newStack;
 }
 InterpStack.prototype.next$0 = function() {
   return this.next();
 };
+// ********** Code for TokenizerHelpers **************
+function TokenizerHelpers() {
+  // Initializers done
+}
+TokenizerHelpers.isIdentifierStart = function(c) {
+  return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
+}
+TokenizerHelpers.isDigit = function(c) {
+  return (c >= 48 && c <= 57);
+}
+TokenizerHelpers.isHexDigit = function(c) {
+  return (TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70));
+}
+TokenizerHelpers.isIdentifierPart = function(c) {
+  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == 36);
+}
+TokenizerHelpers.isInterpIdentifierPart = function(c) {
+  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
+}
 // ********** Code for TokenizerBase **************
+$inherits(TokenizerBase, TokenizerHelpers);
 function TokenizerBase(_source, _skipWhitespace, index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
-  this._index = index;
+  this._lang_index = index;
   // Initializers done
   TokenizerHelpers.call(this);
   this._text = this._source.get$text();
 }
-$inherits(TokenizerBase, TokenizerHelpers);
 TokenizerBase.prototype._nextChar = function() {
-  if (this._index < this._text.length) {
-    return this._text.charCodeAt(this._index++);
+  if (this._lang_index < this._text.length) {
+    return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._peekChar = function() {
-  if (this._index < this._text.length) {
-    return this._text.charCodeAt(this._index);
+  if (this._lang_index < this._text.length) {
+    return this._text.charCodeAt(this._lang_index);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._maybeEatChar = function(ch) {
-  if (this._index < this._text.length) {
-    if (this._text.charCodeAt(this._index) == ch) {
-      this._index++;
+  if (this._lang_index < this._text.length) {
+    if (this._text.charCodeAt(this._lang_index) == ch) {
+      this._lang_index++;
       return true;
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
-  return new Token(kind, this._source, this._startIndex, this._index);
+  return new Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function(message) {
-  return new ErrorToken(65/*TokenKind.ERROR*/, this._source, this._startIndex, this._index, message);
+  return new ErrorToken(65/*TokenKind.ERROR*/, this._source, this._startIndex, this._lang_index, message);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
-  this._index--;
-  while (this._index < this._text.length) {
-    var ch = this._text.charCodeAt(this._index++);
+  this._lang_index--;
+  while (this._lang_index < this._text.length) {
+    var ch = this._text.charCodeAt(this._lang_index++);
     if (ch == 32 || ch == 9 || ch == 13) {
     }
     else if (ch == 10) {
       if (!this._skipWhitespace) {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
     else {
-      this._index--;
+      this._lang_index--;
       if (this._skipWhitespace) {
         return this.next();
       }
       else {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
@@ skipping 31 matching lines @@
         }
         else {
           return this._finishToken(64/*TokenKind.COMMENT*/);
         }
       }
     }
   }
   return this._errorToken();
 }
 TokenizerBase.prototype.eatDigits = function() {
-  while (this._index < this._text.length) {
-    if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._index))) {
-      this._index++;
+  while (this._lang_index < this._text.length) {
+    if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._lang_index))) {
+      this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.eatHexDigits = function() {
-  while (this._index < this._text.length) {
-    if (TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._index))) {
-      this._index++;
+  while (this._lang_index < this._text.length) {
+    if (TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+      this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.maybeEatHexDigit = function() {
-  if (this._index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._index))) {
-    this._index++;
+  if (this._lang_index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+    this._lang_index++;
     return true;
   }
   return false;
 }
 TokenizerBase.prototype.finishHex = function() {
   this.eatHexDigits();
   return this._finishToken(61/*TokenKind.HEX_INTEGER*/);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
   if (this._peekChar() == 46) {
     this._nextChar();
     if (TokenizerHelpers.isDigit(this._peekChar())) {
       this.eatDigits();
       return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
     }
     else {
-      this._index--;
+      this._lang_index--;
     }
   }
   return this.finishNumberExtra(60/*TokenKind.INTEGER*/);
 }
 TokenizerBase.prototype.finishNumberExtra = function(kind) {
   if (this._maybeEatChar(101) || this._maybeEatChar(69)) {
     kind = 62/*TokenKind.DOUBLE*/;
     this._maybeEatChar(45);
     this._maybeEatChar(43);
     this.eatDigits();
@@ skipping 113 matching lines @@
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
       return this.maybeEatHexDigit() && this.maybeEatHexDigit();
 
     case 117:
 
       if (this._maybeEatChar(123)) {
-        var start = this._index;
+        var start = this._lang_index;
         this.eatHexDigits();
-        var chars = this._index - start;
+        var chars = this._lang_index - start;
         if (chars > 0 && chars <= 6 && this._maybeEatChar(125)) {
           hex = this._text.substring(start, start + chars);
           break;
         }
         else {
           return false;
         }
       }
       else {
         if (this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit()) {
-          hex = this._text.substring(this._index - 4, this._index);
+          hex = this._text.substring(this._lang_index - 4, this._lang_index);
           break;
         }
         else {
           return false;
         }
       }
 
     default:
 
       return true;
@@ skipping 10 matching lines @@
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function(ch) {
   if (this._interpStack != null && this._interpStack.depth == -1) {
     this._interpStack.depth = 0;
     if (ch == 36) {
       return this._errorToken("illegal character after $ in string interpolation");
     }
-    while (this._index < this._text.length) {
-      if (!TokenizerHelpers.isInterpIdentifierPart(this._text.charCodeAt(this._index++))) {
-        this._index--;
+    while (this._lang_index < this._text.length) {
+      if (!TokenizerHelpers.isInterpIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
+        this._lang_index--;
         break;
       }
     }
   }
   else {
-    while (this._index < this._text.length) {
-      if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._index++))) {
-        this._index--;
+    while (this._lang_index < this._text.length) {
+      if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
+        this._lang_index--;
         break;
       }
     }
   }
   var kind = this.getIdentifierKind();
   if (kind == 70/*TokenKind.IDENTIFIER*/) {
     return this._finishToken(70/*TokenKind.IDENTIFIER*/);
   }
   else {
     return this._finishToken(kind);
   }
 }
 TokenizerBase.prototype.next$0 = TokenizerBase.prototype.next;
 // ********** Code for Tokenizer **************
+$inherits(Tokenizer, TokenizerBase);
 function Tokenizer(source, skipWhitespace, index) {
   // Initializers done
   TokenizerBase.call(this, source, skipWhitespace, index);
 }
-$inherits(Tokenizer, TokenizerBase);
 Tokenizer.prototype.next = function() {
-  this._startIndex = this._index;
+  this._startIndex = this._lang_index;
   if (this._interpStack != null && this._interpStack.depth == 0) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
     if (istack.get$isMultiline()) {
       return this.finishMultilineString(istack.get$quote());
     }
     else {
       return this.finishStringBody(istack.get$quote());
     }
   }
@@ skipping 314 matching lines @@
         return this.finishNumber();
       }
       else {
         return this._errorToken();
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
-  switch (this._index - i0) {
+  switch (this._lang_index - i0) {
     case 2:
 
       if (this._text.charCodeAt(i0) == 100) {
         if (this._text.charCodeAt(i0 + 1) == 111) return 95/*TokenKind.DO*/;
       }
       else if (this._text.charCodeAt(i0) == 105) {
         if (this._text.charCodeAt(i0 + 1) == 102) {
           return 101/*TokenKind.IF*/;
         }
         else if (this._text.charCodeAt(i0 + 1) == 110) {
@@ skipping 168 matching lines @@
       if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 77/*TokenKind.IMPLEMENTS*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 Tokenizer.prototype.next$0 = Tokenizer.prototype.next;
-// ********** Code for TokenizerHelpers **************
-function TokenizerHelpers() {
-  // Initializers done
-}
-TokenizerHelpers.isIdentifierStart = function(c) {
-  return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
-}
-TokenizerHelpers.isDigit = function(c) {
-  return (c >= 48 && c <= 57);
-}
-TokenizerHelpers.isHexDigit = function(c) {
-  return (TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70));
-}
-TokenizerHelpers.isIdentifierPart = function(c) {
-  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == 36);
-}
-TokenizerHelpers.isInterpIdentifierPart = function(c) {
-  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
-}
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
     case 1/*TokenKind.END_OF_FILE*/:
 
       return "end of file";
 
     case 2/*TokenKind.LPAREN*/:
 
@@ skipping 810 matching lines @@
   this._afterParens = [];
 }
 Parser.prototype.get$enableAwait = function() {
   return $globals.experimentalAwaitPhase != null;
 }
 Parser.prototype.isPrematureEndOfFile = function() {
   if (this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/)) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
-    this._error('unexpected end of file', this._peekToken.get$span());
+    this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
 Parser.prototype._recoverTo = function(kind1, kind2, kind3) {
   while (!this.isPrematureEndOfFile()) {
     var kind = this._peek();
     if (kind == kind1 || kind == kind2 || kind == kind3) {
       this._recover = false;
       return true;
     }
-    this._next();
+    this._lang_next();
   }
   return false;
 }
 Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
-Parser.prototype._next = function() {
+Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
 Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
 Parser.prototype._peekIdentifier = function() {
   return this._isIdentifier(this._peekToken.kind);
 }
@@ skipping 14 matching lines @@
   if (!this._maybeEat(kind)) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 Parser.prototype._eatSemicolon = function() {
   if (this.optionalSemicolons && this._peekKind(1/*TokenKind.END_OF_FILE*/)) return;
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 Parser.prototype._errorExpected = function(expected) {
   if (this.throwOnIncomplete) this.isPrematureEndOfFile();
-  var tok = this._next();
+  var tok = this._lang_next();
   if ((tok instanceof ErrorToken) && tok.get$message() != null) {
-    this._error(tok.get$message(), tok.get$span());
+    this._lang_error(tok.get$message(), tok.get$span());
   }
   else {
-    this._error(('expected ' + expected + ', but found ' + tok), tok.get$span());
+    this._lang_error(('expected ' + expected + ', but found ' + tok), tok.get$span());
   }
 }
-Parser.prototype._error = function(message, location) {
+Parser.prototype._lang_error = function(message, location) {
   if (this._recover) return;
   if (location == null) {
     location = this._peekToken.get$span();
   }
   $globals.world.fatal(message, location);
   this._recover = true;
 }
 Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
-    var tok = this._next();
+    var tok = this._lang_next();
     if ($eq(tok.get$kind(), 6/*TokenKind.LBRACE*/)) {
       depth += 1;
     }
     else if ($eq(tok.get$kind(), 7/*TokenKind.RBRACE*/)) {
       depth -= 1;
       if (depth == 0) return;
     }
     else if ($eq(tok.get$kind(), 1/*TokenKind.END_OF_FILE*/)) {
-      this._error('unexpected end of file during diet parse', tok.get$span());
+      this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
 Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
@@ skipping 120 matching lines @@
     }
     else {
       return this.block();
     }
   }
   else if (!inExpression) {
     if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
       return null;
     }
   }
-  this._error('Expected function body (neither { nor => found)');
+  this._lang_error('Expected function body (neither { nor => found)');
 }
 Parser.prototype.finishField = function(start, modifiers, typeParams, type, name, value) {
   if (typeParams != null) {
     $globals.world.internalError('trying to create a generic field', this._makeSpan(start));
   }
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add$1(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
@@ skipping 46 matching lines @@
 Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if (this._peekKind(75/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators), null);
 }
 Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
-  var factoryToken = this._next();
+  var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add$1(this.identifier());
   }
   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) {
       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) {
-    this._error('unsupported qualified name for factory', names.$index(0).get$span());
+    this._lang_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*/:
 
       return this.breakStatement();
@@ skipping 258 matching lines @@
     }
     else if (this._maybeEat(94/*TokenKind.DEFAULT*/)) {
       cases.add$1();
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
   if ($eq(cases.length, 0)) {
-    this._error('case or default');
+    this._lang_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 64 matching lines @@
     if (type.get$names() == null) {
       type.set$names([expr.get$name()]);
     }
     else {
       type.get$names().add$1(expr.get$name());
     }
     type.set$span(expr.get$span());
     return type;
   }
   else {
-    this._error('expected type reference');
+    this._lang_error('expected type reference');
     return null;
   }
 }
 Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
 Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().get$start())));
 }
@@ skipping 25 matching lines @@
 Parser.prototype.finishInfixExpression = function(x, precedence) {
   while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if (prec >= precedence) {
       if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
         if (this._isBin(x, 52/*TokenKind.LT*/)) {
           return this._fixAsType(x);
         }
       }
-      var op = this._next();
+      var op = this._lang_next();
       if ($eq(op.get$kind(), 103/*TokenKind.IS*/)) {
         var isTrue = !this._maybeEat(19/*TokenKind.NOT*/);
         var typeRef = this.type(0);
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
       var y = this.infixExpression($eq(prec, 2) ? prec : prec + 1);
       if ($eq(op.get$kind(), 33/*TokenKind.CONDITIONAL*/)) {
         this._eat(8/*TokenKind.COLON*/);
         var z = this.infixExpression(prec);
@@ skipping 22 matching lines @@
 
     default:
 
       return false;
 
   }
 }
 Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if (this._isPrefixUnaryOperator(this._peek())) {
-    var tok = this._next();
+    var tok = this._lang_next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
   else if (this.get$enableAwait() && this._maybeEat(88/*TokenKind.AWAIT*/)) {
     var expr = this.unaryExpression();
     return new AwaitExpression(expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
 Parser.prototype.argument = function() {
@@ skipping 44 matching lines @@
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().get$start()));
       return this.finishPostfixExpression(ret);
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
-      var tok = this._next();
+      var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().get$start()));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
       return expr;
 
     default:
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().get$start())));
       }
       else {
         return expr;
       }
 
   }
 }
 Parser.prototype.finishCallOrLambdaExpression = function(expr) {
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
     return this._makeFunction(expr, formals, body);
   }
   else {
     if ((expr instanceof DeclaredIdentifier)) {
-      this._error('illegal target for call, did you mean to declare a function?', expr.get$span());
+      this._lang_error('illegal target for call, did you mean to declare a function?', expr.get$span());
     }
     var args = this.arguments();
     return this.finishPostfixExpression(new CallExpression(expr, args, this._makeSpan(expr.get$span().get$start())));
   }
 }
 Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && $eq(expr.get$op().get$kind(), kind);
 }
 Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, $globals.world.nonNullBool);
@@ skipping 64 matching lines @@
       this._eat(111/*TokenKind.TRUE*/);
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
     case 97/*TokenKind.FALSE*/:
 
       this._eat(97/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
     case 61/*TokenKind.HEX_INTEGER*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Parser.parseHex(t.get$text().substring$1(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 60/*TokenKind.INTEGER*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Math.parseInt(t.get$text()), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 62/*TokenKind.DOUBLE*/:
 
-      var t = this._next();
+      var t = this._lang_next();
       return new LiteralExpression(Math.parseDouble(t.get$text()), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
 
     case 66/*TokenKind.INCOMPLETE_STRING*/:
 
       return this.stringInterpolation();
 
@@ skipping 14 matching lines @@
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while (this._peekKind(66/*TokenKind.INCOMPLETE_STRING*/)) {
-    var token = this._next();
+    var token = this._lang_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;
     }
     else {
       text = startQuote + text.substring$2(0, text.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 {
       var id = this.identifier();
       lits.add$1(new VarExpression(id, id.get$span()));
     }
   }
-  var tok = this._next();
+  var tok = this._lang_next();
   if ($ne(tok.get$kind(), 58/*TokenKind.STRING*/)) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
   lits.add$1(this.makeStringLiteral(text, tok.get$span()));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef(span), '\$\$\$', span);
 }
 Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
 Parser.prototype.stringLiteralExpr = function() {
-  var token = this._next();
+  var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
 Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($eq(kind, 58/*TokenKind.STRING*/)) {
-    return parseStringLiteral(this._next().get$text());
+    return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
-    this._next();
+    this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/)) {
-    this._next();
+    this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
     var func = new FunctionDefinition(null, null, null, formals, null, null, null, body, this._makeSpan(start));
@@ skipping 17 matching lines @@
 Parser.prototype._eatLeftParen = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
   if (this._afterParensIndex < this._afterParens.length) {
     return this._afterParens.$index(this._afterParensIndex);
   }
   this._afterParensIndex = 0;
   this._afterParens.clear();
-  var tokens = [this._next()];
+  var tokens = [this._lang_next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
-  this._next();
+  this._lang_next();
   return after;
 }
 Parser.prototype._lookaheadAfterParens = function(tokens) {
   var saved = this._afterParens.length;
   this._afterParens.add(null);
   while (true) {
-    var token = this._next();
+    var token = this._lang_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*/) {
       this._lookaheadAfterParens(tokens);
     }
   }
 }
 Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
 Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
-      this._error('rest no longer supported', this._previousToken.get$span());
+      this._lang_error('rest no longer supported', this._previousToken.get$span());
       name = this.identifier().get$name();
       break;
 
     case 109/*TokenKind.THIS*/:
 
       this._eat(109/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name());
       break;
 
@@ skipping 21 matching lines @@
       }
       break;
 
     case 83/*TokenKind.OPERATOR*/:
 
       if (!includeOperators) return null;
       this._eat(83/*TokenKind.OPERATOR*/);
       var kind = this._peek();
       if ($eq(kind, 82/*TokenKind.NEGATE*/)) {
         name = ':negate';
-        this._next();
+        this._lang_next();
       }
       else {
         name = TokenKind.binaryMethodName(kind);
         if (name == null) {
           name = 'operator';
         }
         else {
-          this._next();
+          this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
   return new Identifier(name, this._makeSpan(start));
@@ skipping 114 matching lines @@
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
       case 86/*TokenKind.STATIC*/:
       case 98/*TokenKind.FINAL*/:
       case 92/*TokenKind.CONST*/:
       case 71/*TokenKind.ABSTRACT*/:
       case 75/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
-        modifiers.add$1(this._next());
+        modifiers.add$1(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
@@ skipping 80 matching lines @@
 }
 Parser.prototype.nameTypeReference = function() {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
     case 114/*TokenKind.VOID*/:
 
-      return new TypeReference(this._next().get$span(), $globals.world.voidType);
+      return new TypeReference(this._lang_next().get$span(), $globals.world.voidType);
 
     case 113/*TokenKind.VAR*/:
 
-      return new TypeReference(this._next().get$span(), $globals.world.varType);
+      return new TypeReference(this._lang_next().get$span(), $globals.world.varType);
 
     case 98/*TokenKind.FINAL*/:
 
       this._eat(98/*TokenKind.FINAL*/);
       isFinal = true;
       name = this.identifier();
       break;
 
     default:
 
@@ skipping 22 matching lines @@
 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*/)) {
     if (!inOptionalBlock) {
-      this._error('default values only allowed inside [optional] section');
+      this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 Parser.prototype.formalParameterList = function() {
   this._eatLeftParen();
   var formals = [];
   var inOptionalBlock = false;
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
       inOptionalBlock = true;
     }
     formals.add$1(this.formalParameter(inOptionalBlock));
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
         if (inOptionalBlock) {
-          this._error('already inside an optional block', this._previousToken.get$span());
+          this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add$1(this.formalParameter(inOptionalBlock));
     }
     if (inOptionalBlock) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
 Parser.prototype.identifier = function() {
-  var tok = this._next();
+  var tok = this._lang_next();
   if (!this._isIdentifier(tok.get$kind())) {
-    this._error(('expected identifier, but found ' + tok), tok.get$span());
+    this._lang_error(('expected identifier, but found ' + tok), tok.get$span());
   }
   return new Identifier(tok.get$text(), this._makeSpan(tok.get$start()));
 }
 Parser.prototype._makeFunction = function(expr, formals, body) {
   var name, type;
   if ((expr instanceof VarExpression)) {
     name = expr.get$name();
     type = null;
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     name = expr.get$name();
     type = expr.get$type();
   }
   else {
-    this._error('bad function body', expr.get$span());
+    this._lang_error('bad function body', expr.get$span());
   }
   var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
   var func = new FunctionDefinition(null, type, name, formals, null, null, null, body, span);
   return new LambdaExpression(func, func.get$span());
 }
 Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
-    this._error('expected declared identifier');
+    this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
 Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
 Parser.prototype.block$0 = Parser.prototype.block;
 // ********** Code for IncompleteSourceException **************
 function IncompleteSourceException(token) {
   this.token = token;
   // Initializers done
 }
 IncompleteSourceException.prototype.toString = function() {
   if (this.token.get$span() == null) return ('Unexpected ' + this.token);
   return this.token.get$span().toMessageString(('Unexpected ' + this.token));
 }
 IncompleteSourceException.prototype.toString$0 = IncompleteSourceException.prototype.toString;
 // ********** Code for DivertedTokenSource **************
 function DivertedTokenSource(tokens, parser, previousTokenizer) {
-  this._pos = 0
+  this._lang_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) {
+  var token = this.tokens.$index(this._lang_pos);
+  ++this._lang_pos;
+  if (this._lang_pos == this.tokens.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
 }
 Node.prototype.get$span = function() { return this.span; };
 Node.prototype.set$span = function(value) { return this.span = value; };
 Node.prototype.visit$1 = Node.prototype.visit;
+// ********** Code for Statement **************
+$inherits(Statement, Node);
+function Statement(span) {
+  // Initializers done
+  Node.call(this, span);
+}
 // ********** Code for Definition **************
+$inherits(Definition, Statement);
 function Definition(span) {
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(Definition, Statement);
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
 Definition.prototype.get$nativeType = function() {
   return null;
 }
-// ********** Code for Statement **************
-function Statement(span) {
-  // Initializers done
-  Node.call(this, span);
-}
-$inherits(Statement, Node);
 // ********** Code for Expression **************
+$inherits(Expression, Node);
 function Expression(span) {
   // Initializers done
   Node.call(this, span);
 }
-$inherits(Expression, Node);
 // ********** Code for TypeReference **************
+$inherits(TypeReference, Node);
 function TypeReference(span, type) {
   this.type = type;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(TypeReference, Node);
 TypeReference.prototype.get$type = function() { return this.type; };
 TypeReference.prototype.set$type = function(value) { return this.type = value; };
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 TypeReference.prototype.get$isFinal = function() {
   return false;
 }
 TypeReference.prototype.visit$1 = TypeReference.prototype.visit;
 // ********** Code for DirectiveDefinition **************
+$inherits(DirectiveDefinition, Definition);
 function DirectiveDefinition(name, arguments, span) {
   this.name = name;
   this.arguments = arguments;
   // Initializers done
   Definition.call(this, span);
 }
-$inherits(DirectiveDefinition, Definition);
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
 DirectiveDefinition.prototype.get$arguments = function() { return this.arguments; };
 DirectiveDefinition.prototype.set$arguments = function(value) { return this.arguments = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 DirectiveDefinition.prototype.visit$1 = DirectiveDefinition.prototype.visit;
 // ********** Code for TypeDefinition **************
+$inherits(TypeDefinition, Definition);
 function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span) {
   this.isClass = isClass;
   this.name = name;
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
   this.nativeType = nativeType;
   this.factoryType = factoryType;
   this.body = body;
   // Initializers done
   Definition.call(this, span);
 }
-$inherits(TypeDefinition, Definition);
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 TypeDefinition.prototype.set$isClass = function(value) { return this.isClass = value; };
 TypeDefinition.prototype.get$name = function() { return this.name; };
 TypeDefinition.prototype.set$name = function(value) { return this.name = value; };
 TypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 TypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 TypeDefinition.prototype.get$nativeType = function() { return this.nativeType; };
 TypeDefinition.prototype.set$nativeType = function(value) { return this.nativeType = value; };
 TypeDefinition.prototype.get$body = function() { return this.body; };
 TypeDefinition.prototype.set$body = function(value) { return this.body = value; };
 TypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 TypeDefinition.prototype.visit$1 = TypeDefinition.prototype.visit;
 // ********** Code for FunctionTypeDefinition **************
+$inherits(FunctionTypeDefinition, Definition);
 function FunctionTypeDefinition(func, typeParameters, span) {
   this.func = func;
   this.typeParameters = typeParameters;
   // Initializers done
   Definition.call(this, span);
 }
-$inherits(FunctionTypeDefinition, Definition);
 FunctionTypeDefinition.prototype.get$func = function() { return this.func; };
 FunctionTypeDefinition.prototype.set$func = function(value) { return this.func = value; };
 FunctionTypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 FunctionTypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionTypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeDefinition(this);
 }
 FunctionTypeDefinition.prototype.visit$1 = FunctionTypeDefinition.prototype.visit;
 // ********** Code for VariableDefinition **************
+$inherits(VariableDefinition, Definition);
 function VariableDefinition(modifiers, type, names, values, span) {
   this.modifiers = modifiers;
   this.type = type;
   this.names = names;
   this.values = values;
   // Initializers done
   Definition.call(this, span);
 }
-$inherits(VariableDefinition, Definition);
 VariableDefinition.prototype.get$type = function() { return this.type; };
 VariableDefinition.prototype.set$type = function(value) { return this.type = value; };
 VariableDefinition.prototype.get$names = function() { return this.names; };
 VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
 VariableDefinition.prototype.get$values = function() { return this.values; };
 VariableDefinition.prototype.set$values = function(value) { return this.values = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 VariableDefinition.prototype.visit$1 = VariableDefinition.prototype.visit;
 // ********** Code for FunctionDefinition **************
+$inherits(FunctionDefinition, Definition);
 function FunctionDefinition(modifiers, returnType, name, formals, typeParameters, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
   this.typeParameters = typeParameters;
   this.initializers = initializers;
   this.nativeBody = nativeBody;
   this.body = body;
   // Initializers done
   Definition.call(this, span);
 }
-$inherits(FunctionDefinition, Definition);
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 FunctionDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionDefinition.prototype.get$initializers = function() { return this.initializers; };
 FunctionDefinition.prototype.set$initializers = function(value) { return this.initializers = value; };
 FunctionDefinition.prototype.get$nativeBody = function() { return this.nativeBody; };
 FunctionDefinition.prototype.set$nativeBody = function(value) { return this.nativeBody = value; };
 FunctionDefinition.prototype.get$body = function() { return this.body; };
 FunctionDefinition.prototype.set$body = function(value) { return this.body = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 FunctionDefinition.prototype.visit$1 = FunctionDefinition.prototype.visit;
 // ********** Code for ReturnStatement **************
+$inherits(ReturnStatement, Statement);
 function ReturnStatement(value, span) {
   this.value = value;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ReturnStatement, Statement);
 ReturnStatement.prototype.get$value = function() { return this.value; };
 ReturnStatement.prototype.set$value = function(value) { return this.value = value; };
 ReturnStatement.prototype.visit = function(visitor) {
   return visitor.visitReturnStatement(this);
 }
 ReturnStatement.prototype.visit$1 = ReturnStatement.prototype.visit;
 // ********** Code for ThrowStatement **************
+$inherits(ThrowStatement, Statement);
 function ThrowStatement(value, span) {
   this.value = value;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ThrowStatement, Statement);
 ThrowStatement.prototype.get$value = function() { return this.value; };
 ThrowStatement.prototype.set$value = function(value) { return this.value = value; };
 ThrowStatement.prototype.visit = function(visitor) {
   return visitor.visitThrowStatement(this);
 }
 ThrowStatement.prototype.visit$1 = ThrowStatement.prototype.visit;
 // ********** Code for AssertStatement **************
+$inherits(AssertStatement, Statement);
 function AssertStatement(test, span) {
   this.test = test;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(AssertStatement, Statement);
 AssertStatement.prototype.visit = function(visitor) {
   return visitor.visitAssertStatement(this);
 }
 AssertStatement.prototype.visit$1 = AssertStatement.prototype.visit;
 // ********** Code for BreakStatement **************
+$inherits(BreakStatement, Statement);
 function BreakStatement(label, span) {
   this.label = label;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(BreakStatement, Statement);
 BreakStatement.prototype.get$label = function() { return this.label; };
 BreakStatement.prototype.set$label = function(value) { return this.label = value; };
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 BreakStatement.prototype.visit$1 = BreakStatement.prototype.visit;
 // ********** Code for ContinueStatement **************
+$inherits(ContinueStatement, Statement);
 function ContinueStatement(label, span) {
   this.label = label;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ContinueStatement, Statement);
 ContinueStatement.prototype.get$label = function() { return this.label; };
 ContinueStatement.prototype.set$label = function(value) { return this.label = value; };
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 ContinueStatement.prototype.visit$1 = ContinueStatement.prototype.visit;
 // ********** Code for IfStatement **************
+$inherits(IfStatement, Statement);
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(IfStatement, Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 IfStatement.prototype.visit$1 = IfStatement.prototype.visit;
 // ********** Code for WhileStatement **************
+$inherits(WhileStatement, Statement);
 function WhileStatement(test, body, span) {
   this.test = test;
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(WhileStatement, Statement);
 WhileStatement.prototype.get$body = function() { return this.body; };
 WhileStatement.prototype.set$body = function(value) { return this.body = value; };
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 WhileStatement.prototype.visit$1 = WhileStatement.prototype.visit;
 // ********** Code for DoStatement **************
+$inherits(DoStatement, Statement);
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(DoStatement, Statement);
 DoStatement.prototype.get$body = function() { return this.body; };
 DoStatement.prototype.set$body = function(value) { return this.body = value; };
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 DoStatement.prototype.visit$1 = DoStatement.prototype.visit;
 // ********** Code for ForStatement **************
+$inherits(ForStatement, Statement);
 function ForStatement(init, test, step, body, span) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ForStatement, Statement);
 ForStatement.prototype.get$body = function() { return this.body; };
 ForStatement.prototype.set$body = function(value) { return this.body = value; };
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 ForStatement.prototype.visit$1 = ForStatement.prototype.visit;
 // ********** Code for ForInStatement **************
+$inherits(ForInStatement, Statement);
 function ForInStatement(item, list, body, span) {
   this.item = item;
   this.list = list;
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ForInStatement, Statement);
 ForInStatement.prototype.get$body = function() { return this.body; };
 ForInStatement.prototype.set$body = function(value) { return this.body = value; };
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 ForInStatement.prototype.visit$1 = ForInStatement.prototype.visit;
 // ********** Code for TryStatement **************
+$inherits(TryStatement, Statement);
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(TryStatement, Statement);
 TryStatement.prototype.get$body = function() { return this.body; };
 TryStatement.prototype.set$body = function(value) { return this.body = value; };
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 TryStatement.prototype.visit$1 = TryStatement.prototype.visit;
 // ********** Code for SwitchStatement **************
+$inherits(SwitchStatement, Statement);
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(SwitchStatement, Statement);
 SwitchStatement.prototype.get$cases = function() { return this.cases; };
 SwitchStatement.prototype.set$cases = function(value) { return this.cases = value; };
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 SwitchStatement.prototype.visit$1 = SwitchStatement.prototype.visit;
 // ********** Code for BlockStatement **************
+$inherits(BlockStatement, Statement);
 function BlockStatement(body, span) {
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(BlockStatement, Statement);
 BlockStatement.prototype.get$body = function() { return this.body; };
 BlockStatement.prototype.set$body = function(value) { return this.body = value; };
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 BlockStatement.prototype.visit$1 = BlockStatement.prototype.visit;
 // ********** Code for LabeledStatement **************
+$inherits(LabeledStatement, Statement);
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(LabeledStatement, Statement);
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
 LabeledStatement.prototype.get$body = function() { return this.body; };
 LabeledStatement.prototype.set$body = function(value) { return this.body = value; };
 LabeledStatement.prototype.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
 LabeledStatement.prototype.visit$1 = LabeledStatement.prototype.visit;
 // ********** Code for ExpressionStatement **************
+$inherits(ExpressionStatement, Statement);
 function ExpressionStatement(body, span) {
   this.body = body;
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(ExpressionStatement, Statement);
 ExpressionStatement.prototype.get$body = function() { return this.body; };
 ExpressionStatement.prototype.set$body = function(value) { return this.body = value; };
 ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 ExpressionStatement.prototype.visit$1 = ExpressionStatement.prototype.visit;
 // ********** Code for EmptyStatement **************
+$inherits(EmptyStatement, Statement);
 function EmptyStatement(span) {
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(EmptyStatement, Statement);
 EmptyStatement.prototype.visit = function(visitor) {
   return visitor.visitEmptyStatement(this);
 }
 EmptyStatement.prototype.visit$1 = EmptyStatement.prototype.visit;
 // ********** Code for DietStatement **************
+$inherits(DietStatement, Statement);
 function DietStatement(span) {
   // Initializers done
   Statement.call(this, span);
 }
-$inherits(DietStatement, Statement);
 DietStatement.prototype.visit = function(visitor) {
   return visitor.visitDietStatement(this);
 }
 DietStatement.prototype.visit$1 = DietStatement.prototype.visit;
 // ********** Code for LambdaExpression **************
+$inherits(LambdaExpression, Expression);
 function LambdaExpression(func, span) {
   this.func = func;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(LambdaExpression, Expression);
 LambdaExpression.prototype.get$func = function() { return this.func; };
 LambdaExpression.prototype.set$func = function(value) { return this.func = value; };
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 LambdaExpression.prototype.visit$1 = LambdaExpression.prototype.visit;
 // ********** Code for CallExpression **************
+$inherits(CallExpression, Expression);
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(CallExpression, Expression);
 CallExpression.prototype.get$target = function() { return this.target; };
 CallExpression.prototype.set$target = function(value) { return this.target = value; };
 CallExpression.prototype.get$arguments = function() { return this.arguments; };
 CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 CallExpression.prototype.visit$1 = CallExpression.prototype.visit;
 // ********** Code for IndexExpression **************
+$inherits(IndexExpression, Expression);
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(IndexExpression, Expression);
 IndexExpression.prototype.get$target = function() { return this.target; };
 IndexExpression.prototype.set$target = function(value) { return this.target = value; };
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 IndexExpression.prototype.visit$1 = IndexExpression.prototype.visit;
 // ********** Code for BinaryExpression **************
+$inherits(BinaryExpression, Expression);
 function BinaryExpression(op, x, y, span) {
   this.op = op;
   this.x = x;
   this.y = y;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(BinaryExpression, Expression);
 BinaryExpression.prototype.get$op = function() { return this.op; };
 BinaryExpression.prototype.set$op = function(value) { return this.op = value; };
 BinaryExpression.prototype.get$x = function() { return this.x; };
 BinaryExpression.prototype.set$x = function(value) { return this.x = value; };
 BinaryExpression.prototype.get$y = function() { return this.y; };
 BinaryExpression.prototype.set$y = function(value) { return this.y = value; };
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression$1(this);
 }
 BinaryExpression.prototype.visit$1 = BinaryExpression.prototype.visit;
 // ********** Code for UnaryExpression **************
+$inherits(UnaryExpression, Expression);
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(UnaryExpression, Expression);
 UnaryExpression.prototype.get$op = function() { return this.op; };
 UnaryExpression.prototype.set$op = function(value) { return this.op = value; };
 UnaryExpression.prototype.get$self = function() { return this.self; };
 UnaryExpression.prototype.set$self = function(value) { return this.self = value; };
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 UnaryExpression.prototype.visit$1 = UnaryExpression.prototype.visit;
 // ********** Code for PostfixExpression **************
+$inherits(PostfixExpression, Expression);
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(PostfixExpression, Expression);
 PostfixExpression.prototype.get$body = function() { return this.body; };
 PostfixExpression.prototype.set$body = function(value) { return this.body = value; };
 PostfixExpression.prototype.get$op = function() { return this.op; };
 PostfixExpression.prototype.set$op = function(value) { return this.op = value; };
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 PostfixExpression.prototype.visit$1 = PostfixExpression.prototype.visit;
 // ********** Code for NewExpression **************
+$inherits(NewExpression, Expression);
 function NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(NewExpression, Expression);
 NewExpression.prototype.get$isConst = function() { return this.isConst; };
 NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 NewExpression.prototype.get$type = function() { return this.type; };
 NewExpression.prototype.set$type = function(value) { return this.type = value; };
 NewExpression.prototype.get$name = function() { return this.name; };
 NewExpression.prototype.set$name = function(value) { return this.name = value; };
 NewExpression.prototype.get$arguments = function() { return this.arguments; };
 NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 NewExpression.prototype.visit$1 = NewExpression.prototype.visit;
 // ********** Code for ListExpression **************
+$inherits(ListExpression, Expression);
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(ListExpression, Expression);
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 ListExpression.prototype.get$type = function() { return this.type; };
 ListExpression.prototype.set$type = function(value) { return this.type = value; };
 ListExpression.prototype.get$values = function() { return this.values; };
 ListExpression.prototype.set$values = function(value) { return this.values = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 ListExpression.prototype.visit$1 = ListExpression.prototype.visit;
 // ********** Code for MapExpression **************
+$inherits(MapExpression, Expression);
 function MapExpression(isConst, type, items, span) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(MapExpression, Expression);
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 MapExpression.prototype.get$type = function() { return this.type; };
 MapExpression.prototype.set$type = function(value) { return this.type = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 MapExpression.prototype.visit$1 = MapExpression.prototype.visit;
 // ********** Code for ConditionalExpression **************
+$inherits(ConditionalExpression, Expression);
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(ConditionalExpression, Expression);
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 ConditionalExpression.prototype.visit$1 = ConditionalExpression.prototype.visit;
 // ********** Code for IsExpression **************
+$inherits(IsExpression, Expression);
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(IsExpression, Expression);
 IsExpression.prototype.get$x = function() { return this.x; };
 IsExpression.prototype.set$x = function(value) { return this.x = value; };
 IsExpression.prototype.get$type = function() { return this.type; };
 IsExpression.prototype.set$type = function(value) { return this.type = value; };
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 IsExpression.prototype.visit$1 = IsExpression.prototype.visit;
 // ********** Code for ParenExpression **************
+$inherits(ParenExpression, Expression);
 function ParenExpression(body, span) {
   this.body = body;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(ParenExpression, Expression);
 ParenExpression.prototype.get$body = function() { return this.body; };
 ParenExpression.prototype.set$body = function(value) { return this.body = value; };
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 ParenExpression.prototype.visit$1 = ParenExpression.prototype.visit;
 // ********** Code for AwaitExpression **************
+$inherits(AwaitExpression, Expression);
 function AwaitExpression(body, span) {
   this.body = body;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(AwaitExpression, Expression);
 AwaitExpression.prototype.get$body = function() { return this.body; };
 AwaitExpression.prototype.set$body = function(value) { return this.body = value; };
 AwaitExpression.prototype.visit = function(visitor) {
   return visitor.visitAwaitExpression(this);
 }
 AwaitExpression.prototype.visit$1 = AwaitExpression.prototype.visit;
 // ********** Code for DotExpression **************
+$inherits(DotExpression, Expression);
 function DotExpression(self, name, span) {
   this.self = self;
   this.name = name;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(DotExpression, Expression);
 DotExpression.prototype.get$self = function() { return this.self; };
 DotExpression.prototype.set$self = function(value) { return this.self = value; };
 DotExpression.prototype.get$name = function() { return this.name; };
 DotExpression.prototype.set$name = function(value) { return this.name = value; };
 DotExpression.prototype.visit = function(visitor) {
   return visitor.visitDotExpression(this);
 }
 DotExpression.prototype.visit$1 = DotExpression.prototype.visit;
 // ********** Code for VarExpression **************
+$inherits(VarExpression, Expression);
 function VarExpression(name, span) {
   this.name = name;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(VarExpression, Expression);
 VarExpression.prototype.get$name = function() { return this.name; };
 VarExpression.prototype.set$name = function(value) { return this.name = value; };
 VarExpression.prototype.visit = function(visitor) {
   return visitor.visitVarExpression(this);
 }
 VarExpression.prototype.visit$1 = VarExpression.prototype.visit;
 // ********** Code for ThisExpression **************
+$inherits(ThisExpression, Expression);
 function ThisExpression(span) {
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(ThisExpression, Expression);
 ThisExpression.prototype.visit = function(visitor) {
   return visitor.visitThisExpression(this);
 }
 ThisExpression.prototype.visit$1 = ThisExpression.prototype.visit;
 // ********** Code for SuperExpression **************
+$inherits(SuperExpression, Expression);
 function SuperExpression(span) {
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(SuperExpression, Expression);
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 SuperExpression.prototype.visit$1 = SuperExpression.prototype.visit;
 // ********** Code for NullExpression **************
+$inherits(NullExpression, Expression);
 function NullExpression(span) {
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(NullExpression, Expression);
 NullExpression.prototype.visit = function(visitor) {
   return visitor.visitNullExpression(this);
 }
 NullExpression.prototype.visit$1 = NullExpression.prototype.visit;
 // ********** Code for LiteralExpression **************
+$inherits(LiteralExpression, Expression);
 function LiteralExpression(value, type, text, span) {
   this.value = value;
   this.type = type;
   this.text = text;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(LiteralExpression, Expression);
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.get$type = function() { return this.type; };
 LiteralExpression.prototype.set$type = function(value) { return this.type = value; };
 LiteralExpression.prototype.get$text = function() { return this.text; };
 LiteralExpression.prototype.set$text = function(value) { return this.text = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 LiteralExpression.prototype.visit$1 = LiteralExpression.prototype.visit;
 // ********** Code for NameTypeReference **************
+$inherits(NameTypeReference, TypeReference);
 function NameTypeReference(isFinal, name, names, span) {
   this.isFinal = isFinal;
   this.name = name;
   this.names = names;
   // Initializers done
   TypeReference.call(this, span);
 }
-$inherits(NameTypeReference, TypeReference);
 NameTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
 NameTypeReference.prototype.set$isFinal = function(value) { return this.isFinal = value; };
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
 NameTypeReference.prototype.get$names = function() { return this.names; };
 NameTypeReference.prototype.set$names = function(value) { return this.names = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 NameTypeReference.prototype.visit$1 = NameTypeReference.prototype.visit;
 // ********** Code for GenericTypeReference **************
+$inherits(GenericTypeReference, TypeReference);
 function GenericTypeReference(baseType, typeArguments, depth, span) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
   // Initializers done
   TypeReference.call(this, span);
 }
-$inherits(GenericTypeReference, TypeReference);
 GenericTypeReference.prototype.get$baseType = function() { return this.baseType; };
 GenericTypeReference.prototype.set$baseType = function(value) { return this.baseType = value; };
 GenericTypeReference.prototype.get$typeArguments = function() { return this.typeArguments; };
 GenericTypeReference.prototype.set$typeArguments = function(value) { return this.typeArguments = value; };
 GenericTypeReference.prototype.get$depth = function() { return this.depth; };
 GenericTypeReference.prototype.set$depth = function(value) { return this.depth = value; };
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 GenericTypeReference.prototype.visit$1 = GenericTypeReference.prototype.visit;
 // ********** Code for FunctionTypeReference **************
+$inherits(FunctionTypeReference, TypeReference);
 function FunctionTypeReference(isFinal, func, span) {
   this.isFinal = isFinal;
   this.func = func;
   // Initializers done
   TypeReference.call(this, span);
 }
-$inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
 FunctionTypeReference.prototype.set$isFinal = function(value) { return this.isFinal = value; };
 FunctionTypeReference.prototype.get$func = function() { return this.func; };
 FunctionTypeReference.prototype.set$func = function(value) { return this.func = value; };
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 FunctionTypeReference.prototype.visit$1 = FunctionTypeReference.prototype.visit;
 // ********** Code for ArgumentNode **************
+$inherits(ArgumentNode, Node);
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(ArgumentNode, Node);
 ArgumentNode.prototype.get$label = function() { return this.label; };
 ArgumentNode.prototype.set$label = function(value) { return this.label = value; };
 ArgumentNode.prototype.get$value = function() { return this.value; };
 ArgumentNode.prototype.set$value = function(value) { return this.value = value; };
 ArgumentNode.prototype.visit = function(visitor) {
   return visitor.visitArgumentNode(this);
 }
 ArgumentNode.prototype.visit$1 = ArgumentNode.prototype.visit;
 // ********** Code for FormalNode **************
+$inherits(FormalNode, Node);
 function FormalNode(isThis, isRest, type, name, value, span) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
   this.name = name;
   this.value = value;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(FormalNode, Node);
 FormalNode.prototype.get$type = function() { return this.type; };
 FormalNode.prototype.set$type = function(value) { return this.type = value; };
 FormalNode.prototype.get$name = function() { return this.name; };
 FormalNode.prototype.set$name = function(value) { return this.name = value; };
 FormalNode.prototype.get$value = function() { return this.value; };
 FormalNode.prototype.set$value = function(value) { return this.value = value; };
 FormalNode.prototype.visit = function(visitor) {
   return visitor.visitFormalNode(this);
 }
 FormalNode.prototype.visit$1 = FormalNode.prototype.visit;
 // ********** Code for CatchNode **************
+$inherits(CatchNode, Node);
 function CatchNode(exception, trace, body, span) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(CatchNode, Node);
 CatchNode.prototype.get$exception = function() { return this.exception; };
 CatchNode.prototype.set$exception = function(value) { return this.exception = value; };
 CatchNode.prototype.get$trace = function() { return this.trace; };
 CatchNode.prototype.set$trace = function(value) { return this.trace = value; };
 CatchNode.prototype.get$body = function() { return this.body; };
 CatchNode.prototype.set$body = function(value) { return this.body = value; };
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 CatchNode.prototype.visit$1 = CatchNode.prototype.visit;
 // ********** Code for CaseNode **************
+$inherits(CaseNode, Node);
 function CaseNode(label, cases, statements, span) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(CaseNode, Node);
 CaseNode.prototype.get$label = function() { return this.label; };
 CaseNode.prototype.set$label = function(value) { return this.label = value; };
 CaseNode.prototype.get$cases = function() { return this.cases; };
 CaseNode.prototype.set$cases = function(value) { return this.cases = value; };
 CaseNode.prototype.get$statements = function() { return this.statements; };
 CaseNode.prototype.set$statements = function(value) { return this.statements = value; };
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 CaseNode.prototype.visit$1 = CaseNode.prototype.visit;
 // ********** Code for TypeParameter **************
+$inherits(TypeParameter, Node);
 function TypeParameter(name, extendsType, span) {
   this.name = name;
   this.extendsType = extendsType;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(TypeParameter, Node);
 TypeParameter.prototype.get$name = function() { return this.name; };
 TypeParameter.prototype.set$name = function(value) { return this.name = value; };
 TypeParameter.prototype.get$extendsType = function() { return this.extendsType; };
 TypeParameter.prototype.set$extendsType = function(value) { return this.extendsType = value; };
 TypeParameter.prototype.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
 TypeParameter.prototype.visit$1 = TypeParameter.prototype.visit;
 // ********** Code for Identifier **************
+$inherits(Identifier, Node);
 function Identifier(name, span) {
   this.name = name;
   // Initializers done
   Node.call(this, span);
 }
-$inherits(Identifier, Node);
 Identifier.prototype.get$name = function() { return this.name; };
 Identifier.prototype.set$name = function(value) { return this.name = value; };
 Identifier.prototype.visit = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 Identifier.prototype.visit$1 = Identifier.prototype.visit;
 // ********** Code for DeclaredIdentifier **************
+$inherits(DeclaredIdentifier, Expression);
 function DeclaredIdentifier(type, name, span) {
   this.type = type;
   this.name = name;
   // Initializers done
   Expression.call(this, span);
 }
-$inherits(DeclaredIdentifier, Expression);
 DeclaredIdentifier.prototype.get$type = function() { return this.type; };
 DeclaredIdentifier.prototype.set$type = function(value) { return this.type = value; };
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 DeclaredIdentifier.prototype.visit$1 = DeclaredIdentifier.prototype.visit;
 // ********** Code for Type **************
+$inherits(Type, Element);
 function Type(name) {
   this.isTested = false
   this.isChecked = false
+  this.isWritten = false
   this._resolvedMembers = new HashMapImplementation();
   this.varStubs = new HashMapImplementation();
   // Initializers done
   Element.call(this, name, null);
 }
-$inherits(Type, Element);
 Type.prototype.get$isTested = function() { return this.isTested; };
 Type.prototype.set$isTested = function(value) { return this.isTested = value; };
 Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
 Type.prototype.set$typeCheckCode = function(value) { return this.typeCheckCode = value; };
 Type.prototype.get$varStubs = function() { return this.varStubs; };
 Type.prototype.set$varStubs = function(value) { return this.varStubs = value; };
 Type.prototype.markUsed = function() {
 
 }
 Type.prototype.get$typeMember = function() {
@@ skipping 313 matching lines @@
 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;
 Type.prototype.isAssignable$1 = Type.prototype.isAssignable;
 Type.prototype.isSubtypeOf$1 = Type.prototype.isSubtypeOf;
 Type.prototype.markUsed$0 = Type.prototype.markUsed;
 Type.prototype.resolveTypeParams$1 = Type.prototype.resolveTypeParams;
 // ********** Code for ParameterType **************
+$inherits(ParameterType, Type);
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
   // Initializers done
   Type.call(this, name);
 }
-$inherits(ParameterType, Type);
 ParameterType.prototype.get$typeParameter = function() { return this.typeParameter; };
 ParameterType.prototype.set$typeParameter = function(value) { return this.typeParameter = value; };
 ParameterType.prototype.get$extendsType = function() { return this.extendsType; };
 ParameterType.prototype.set$extendsType = function(value) { return this.extendsType = value; };
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
@@ skipping 35 matching lines @@
     this.extendsType = $globals.world.objectType;
   }
 }
 ParameterType.prototype.addDirectSubtype$1 = ParameterType.prototype.addDirectSubtype;
 ParameterType.prototype.getConstructor$1 = ParameterType.prototype.getConstructor;
 ParameterType.prototype.getOrMakeConcreteType$1 = ParameterType.prototype.getOrMakeConcreteType;
 ParameterType.prototype.isSubtypeOf$1 = ParameterType.prototype.isSubtypeOf;
 ParameterType.prototype.resolve$0 = ParameterType.prototype.resolve;
 ParameterType.prototype.resolveTypeParams$1 = ParameterType.prototype.resolveTypeParams;
 // ********** Code for NonNullableType **************
+$inherits(NonNullableType, Type);
 function NonNullableType(type) {
   this.type = type;
   // Initializers done
   Type.call(this, type.name);
 }
-$inherits(NonNullableType, Type);
 NonNullableType.prototype.get$type = function() { return this.type; };
 NonNullableType.prototype.get$isNullable = function() {
   return false;
 }
 NonNullableType.prototype.get$isBool = function() {
   return this.type.get$isBool();
 }
 NonNullableType.prototype.get$isUsed = function() {
   return false;
 }
@@ skipping 86 matching lines @@
 }
 NonNullableType.prototype.addDirectSubtype$1 = NonNullableType.prototype.addDirectSubtype;
 NonNullableType.prototype.getConstructor$1 = NonNullableType.prototype.getConstructor;
 NonNullableType.prototype.getFactory$2 = NonNullableType.prototype.getFactory;
 NonNullableType.prototype.getMember$1 = NonNullableType.prototype.getMember;
 NonNullableType.prototype.getOrMakeConcreteType$1 = NonNullableType.prototype.getOrMakeConcreteType;
 NonNullableType.prototype.isSubtypeOf$1 = NonNullableType.prototype.isSubtypeOf;
 NonNullableType.prototype.markUsed$0 = NonNullableType.prototype.markUsed;
 NonNullableType.prototype.resolveTypeParams$1 = NonNullableType.prototype.resolveTypeParams;
 // ********** Code for ConcreteType **************
+$inherits(ConcreteType, Type);
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.isUsed = false
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = new HashMapImplementation();
   this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
 }
-$inherits(ConcreteType, Type);
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
 ConcreteType.prototype.get$typeArguments = function() { return this.typeArguments; };
 ConcreteType.prototype.set$typeArguments = function(value) { return this.typeArguments = value; };
 ConcreteType.prototype.get$_parent = function() { return this._parent; };
 ConcreteType.prototype.set$_parent = function(value) { return this._parent = value; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
@@ skipping 137 matching lines @@
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = ConcreteType.prototype.addDirectSubtype;
 ConcreteType.prototype.getConstructor$1 = ConcreteType.prototype.getConstructor;
 ConcreteType.prototype.getFactory$2 = ConcreteType.prototype.getFactory;
 ConcreteType.prototype.getMember$1 = ConcreteType.prototype.getMember;
 ConcreteType.prototype.getOrMakeConcreteType$1 = ConcreteType.prototype.getOrMakeConcreteType;
 ConcreteType.prototype.markUsed$0 = ConcreteType.prototype.markUsed;
 ConcreteType.prototype.resolveTypeParams$1 = ConcreteType.prototype.resolveTypeParams;
 // ********** Code for DefinedType **************
+$inherits(DefinedType, Type);
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNative = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = new HashSetImplementation();
   this.constructors = new HashMapImplementation();
   this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
   this.setDefinition(definition);
 }
-$inherits(DefinedType, Type);
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$_parent = function() { return this._parent; };
 DefinedType.prototype.set$_parent = function(value) { return this._parent = value; };
 DefinedType.prototype.get$parent = function() {
   return this._parent;
 }
 DefinedType.prototype.set$parent = function(p) {
@@ skipping 484 matching lines @@
 };
 FixedCollection.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FixedCollection.prototype.isEmpty$0 = FixedCollection.prototype.isEmpty;
 FixedCollection.prototype.iterator$0 = FixedCollection.prototype.iterator;
 FixedCollection.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for FixedCollection_Type **************
+$inherits(FixedCollection_Type, FixedCollection);
 function FixedCollection_Type(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
-$inherits(FixedCollection_Type, FixedCollection);
 // ********** 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.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 **************
+$inherits(FixedIterator_E, FixedIterator);
 function FixedIterator_E(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
-$inherits(FixedIterator_E, FixedIterator);
 // ********** Code for Value **************
 function Value(_type, code, span, needsTemp) {
   this.isSuper = false
   this.isType = false
   this.isInitializerTarget = false
   this.isFinal = false
   this._type = _type;
   this.code = code;
   this.span = span;
   this.needsTemp = needsTemp;
@@ skipping 339 matching lines @@
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 Value.prototype.invoke$4$isDynamic = Value.prototype.invoke;
 Value.prototype.invoke$5 = Value.prototype.invoke;
 Value.prototype.needsConversion$1 = Value.prototype.needsConversion;
 Value.prototype.set_$4 = function($0, $1, $2, $3) {
   return this.set_($0, $1, $2, $3, false);
 };
 // ********** Code for EvaluatedValue **************
+$inherits(EvaluatedValue, Value);
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, span, code) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   // Initializers done
   Value.call(this, type, code, span, false);
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
-$inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
   return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
 EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 EvaluatedValue.codeWithComments = function(canonicalCode, span) {
   return (span != null && span.get$text() != canonicalCode) ? ('' + canonicalCode + '/*' + _escapeForComment(span.get$text()) + '*/') : canonicalCode;
 }
 // ********** Code for ConstListValue **************
+$inherits(ConstListValue, EvaluatedValue);
 function ConstListValue() {}
 ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   // Initializers done
   EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
-$inherits(ConstListValue, EvaluatedValue);
 ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, span) {
   return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 ConstListValue.prototype.get$values = function() { return this.values; };
 ConstListValue.prototype.set$values = function(value) { return this.values = value; };
 // ********** Code for ConstMapValue **************
+$inherits(ConstMapValue, EvaluatedValue);
 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;
-$inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
   var values = new HashMapImplementation();
   for (var i = 0;
    i < keyValuePairs.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) {
   this.fields = fields;
   // Initializers done
   EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
-$inherits(ConstObjectValue, EvaluatedValue);
 ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, span) {
   var fieldValues = [];
   var $$list = fields.getKeys();
   for (var $$i = fields.getKeys().iterator$0(); $$i.hasNext$0(); ) {
     var f = $$i.next$0();
     fieldValues.add(('' + f + ' = ' + fields.$index(f).get$actualValue()));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo$1(b);
   })
   );
   var actualValue = ('const ' + type.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
   return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 ConstObjectValue.prototype.get$fields = function() { return this.fields; };
 ConstObjectValue.prototype.set$fields = function(value) { return this.fields = value; };
 // ********** 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++) {
     var dep = _dependencies.$index($$i);
     this.dependencies.add(dep);
     this.dependencies.addAll(dep.get$dependencies());
   }
 }
-$inherits(GlobalValue, Value);
 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);
   })
   ));
 }
 GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
   var name = ("const\$" + uniqueId);
@@ skipping 43 matching lines @@
   }
   else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 GlobalValue.prototype.compareTo$1 = GlobalValue.prototype.compareTo;
 // ********** Code for BareValue **************
+$inherits(BareValue, Value);
 function BareValue(home, outermost, span) {
   this.home = home;
   // Initializers done
   Value.call(this, outermost.method.declaringType, null, span, false);
   this.isType = outermost.get$isStatic();
 }
-$inherits(BareValue, Value);
 BareValue.prototype.get$type = function() {
   return this._type;
 }
 BareValue.prototype._ensureCode = function() {
   if (this.code != null) return;
   if (this.isType) {
     this.code = this.get$type().get$jsname();
   }
   else {
     this.code = this.home._makeThisCode();
@@ skipping 10 matching lines @@
   }
   member = this.home.get$library().lookup(name, this.span);
   if (member != null) {
     return member;
   }
   this._ensureCode();
   return null;
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
-  this._message = _message;
+  this._lang_message = _message;
   this._location = _location;
   // Initializers done
 }
 CompilerException.prototype.toString = function() {
   if (this._location != null) {
-    return ('CompilerException: ' + this._location.toMessageString(this._message));
+    return ('CompilerException: ' + this._location.toMessageString(this._lang_message));
   }
   else {
-    return ('CompilerException: ' + this._message);
+    return ('CompilerException: ' + this._lang_message);
   }
 }
 CompilerException.prototype.toString$0 = CompilerException.prototype.toString;
 // ********** Code for World **************
 function World(files) {
   this.errors = 0
   this.warnings = 0
   this.dartBytesRead = 0
   this.jsBytesWritten = 0
   this.seenFatal = false
@@ skipping 511 matching lines @@
 VarMember.prototype.get$name = function() { return this.name; };
 VarMember.prototype.get$returnType = function() {
   return $globals.world.varType;
 }
 VarMember.prototype.invoke = function(context, node, target, args) {
   return new Value(this.get$returnType(), ('' + target.code + '.' + this.name + '(' + args.getCode() + ')'), node.span, true);
 }
 VarMember.prototype.generate$1 = VarMember.prototype.generate;
 VarMember.prototype.invoke$4 = VarMember.prototype.invoke;
 // ********** Code for VarFunctionStub **************
+$inherits(VarFunctionStub, VarMember);
 function VarFunctionStub(name, callArgs) {
   this.args = callArgs.toCallStubArgs();
   // Initializers done
   VarMember.call(this, name);
   $globals.world.gen.corejs.useGenStub = true;
 }
-$inherits(VarFunctionStub, VarMember);
 VarFunctionStub.prototype.generate = function(code) {
   if (this.args.get$hasNames()) {
     this.generateNamed(code);
   }
   else {
     this.generatePositional(code);
   }
 }
 VarFunctionStub.prototype.generatePositional = function(w) {
   var arity = this.args.get$length();
@@ skipping 11 matching lines @@
 VarFunctionStub.prototype.generateNamed = function(w) {
   var named = Strings.join(this.args.getNames(), '", "');
   var argsCode = this.args.getCode();
   w.enterBlock(('Function.prototype.' + this.name + ' = function(' + argsCode + ') {'));
   w.writeln(('this.' + this.name + ' = this.\$genStub(' + this.args.get$length() + ', ["' + named + '"]);'));
   w.writeln(('return this.' + this.name + '(' + argsCode + ');'));
   w.exitBlock('}');
 }
 VarFunctionStub.prototype.generate$1 = VarFunctionStub.prototype.generate;
 // ********** Code for VarMethodStub **************
+$inherits(VarMethodStub, VarMember);
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   // Initializers done
   VarMember.call(this, name);
 }
-$inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$body = function() { return this.body; };
 VarMethodStub.prototype.get$isHidden = function() {
   return this.member != null ? this.member.declaringType.get$isHiddenNativeType() : false;
 }
 VarMethodStub.prototype.get$returnType = function() {
   return this.member != null ? this.member.get$returnType() : $globals.world.varType;
 }
 VarMethodStub.prototype.get$declaringType = function() {
   return this.member != null ? this.member.declaringType : $globals.world.objectType;
 }
@@ skipping 40 matching lines @@
       }
     }
     return method.namesInOrder(args);
   }
   else {
     return false;
   }
 }
 VarMethodStub.prototype.generate$1 = VarMethodStub.prototype.generate;
 // ********** Code for VarMethodSet **************
+$inherits(VarMethodSet, VarMember);
 function VarMethodSet(baseName, name, members, callArgs, returnType) {
   this.invoked = false
   this.baseName = baseName;
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   // Initializers done
   VarMember.call(this, name);
 }
-$inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$members = function() { return this.members; };
 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;
@@ skipping 197 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();