continued cleanup of initialization and Value

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
     Error.captureStackTrace(e, $throw);
   }
@@ skipping 64 matching lines @@
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
 Object.prototype._checkExtends$0 = function() {
   return this.noSuchMethod("_checkExtends", []);
 };
 Object.prototype._checkNonStatic$1 = function($0) {
   return this.noSuchMethod("_checkNonStatic", [$0]);
 };
+Object.prototype._evalConstConstructor$2 = function($0, $1) {
+  return this.noSuchMethod("_evalConstConstructor", [$0, $1]);
+};
 Object.prototype._get$3 = function($0, $1, $2) {
   return this.noSuchMethod("_get", [$0, $1, $2]);
 };
 Object.prototype._get$3$isDynamic = function($0, $1, $2, isDynamic) {
   return this.noSuchMethod("_get", [$0, $1, $2, isDynamic]);
 };
 Object.prototype._get$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("_get", [$0, $1, $2, $3]);
 };
 Object.prototype._set$4 = function($0, $1, $2, $3) {
@@ skipping 55 matching lines @@
 };
 Object.prototype.end$0 = function() {
   return this.noSuchMethod("end", []);
 };
 Object.prototype.endsWith$1 = function($0) {
   return this.noSuchMethod("endsWith", [$0]);
 };
 Object.prototype.ensureSubtypeOf$3 = function($0, $1, $2) {
   return this.noSuchMethod("ensureSubtypeOf", [$0, $1, $2]);
 };
+Object.prototype.evalBody$2 = function($0, $1) {
+  return this.noSuchMethod("evalBody", [$0, $1]);
+};
 Object.prototype.every$1 = function($0) {
   return this.noSuchMethod("every", [$0]);
 };
 Object.prototype.filter$1 = function($0) {
   return this.noSuchMethod("filter", [$0]);
 };
 Object.prototype.findTypeByName$1 = function($0) {
   return this.noSuchMethod("findTypeByName", [$0]);
 };
 Object.prototype.forEach$1 = function($0) {
@@ skipping 37 matching lines @@
 };
 Object.prototype.hasNext$0 = function() {
   return this.noSuchMethod("hasNext", []);
 };
 Object.prototype.hashCode$0 = function() {
   return this.noSuchMethod("hashCode", []);
 };
 Object.prototype.indexOf$1 = function($0) {
   return this.noSuchMethod("indexOf", [$0]);
 };
+Object.prototype.initFields$0 = function() {
+  return this.noSuchMethod("initFields", []);
+};
 Object.prototype.instanceOf$3$isTrue$forceCheck = function($0, $1, $2, isTrue, forceCheck) {
   return this.noSuchMethod("instanceOf", [$0, $1, $2, isTrue, forceCheck]);
 };
 Object.prototype.instanceOf$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("instanceOf", [$0, $1, $2, $3]);
 };
 Object.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("invoke", [$0, $1, $2, $3]);
 };
 Object.prototype.invoke$4$isDynamic = function($0, $1, $2, $3, isDynamic) {
@@ skipping 70 matching lines @@
 };
 Object.prototype.startsWith$1 = function($0) {
   return this.noSuchMethod("startsWith", [$0]);
 };
 Object.prototype.substring$1 = function($0) {
   return this.noSuchMethod("substring", [$0]);
 };
 Object.prototype.substring$2 = function($0, $1) {
   return this.noSuchMethod("substring", [$0, $1]);
 };
-Object.prototype.toDouble$0 = function() {
-  return this.noSuchMethod("toDouble", []);
-};
-Object.prototype.toInt$0 = function() {
-  return this.noSuchMethod("toInt", []);
-};
 Object.prototype.toRadixString$1 = function($0) {
   return this.noSuchMethod("toRadixString", [$0]);
 };
 Object.prototype.toString$0 = function() {
   return this.toString();
 };
+Object.prototype.unop$3 = function($0, $1, $2) {
+  return this.noSuchMethod("unop", [$0, $1, $2]);
+};
 Object.prototype.visit$1 = function($0) {
   return this.noSuchMethod("visit", [$0]);
 };
 Object.prototype.visitBinaryExpression$1 = function($0) {
   return this.noSuchMethod("visitBinaryExpression", [$0]);
 };
 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 IllegalAccessException **************
 function IllegalAccessException() {
-  // Initializers done
+
 }
 IllegalAccessException.prototype.toString = function() {
   return "Attempt to modify an immutable object";
 }
 IllegalAccessException.prototype.toString$0 = IllegalAccessException.prototype.toString;
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments) {
   this._receiver = _receiver;
   this._functionName = _functionName;
   this._arguments = _arguments;
-  // Initializers done
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = (0);
    i < this._arguments.get$length(); i++) {
     if (i > (0)) {
       sb.add(", ");
     }
     sb.add(this._arguments.$index(i));
   }
   sb.add("]");
   return ("NoSuchMethodException - receiver: '" + this._receiver + "' ") + ("function name: '" + this._functionName + "' arguments: [" + sb + "]");
 }
 NoSuchMethodException.prototype.toString$0 = NoSuchMethodException.prototype.toString;
 // ********** Code for ClosureArgumentMismatchException **************
 function ClosureArgumentMismatchException() {
-  // Initializers done
+
 }
 ClosureArgumentMismatchException.prototype.toString = function() {
   return "Closure argument mismatch";
 }
 ClosureArgumentMismatchException.prototype.toString$0 = ClosureArgumentMismatchException.prototype.toString;
 // ********** Code for ObjectNotClosureException **************
 function ObjectNotClosureException() {
-  // Initializers done
+
 }
 ObjectNotClosureException.prototype.toString = function() {
   return "Object is not closure";
 }
 ObjectNotClosureException.prototype.toString$0 = ObjectNotClosureException.prototype.toString;
 // ********** Code for StackOverflowException **************
 function StackOverflowException() {
-  // Initializers done
+
 }
 StackOverflowException.prototype.toString = function() {
   return "Stack Overflow";
 }
 StackOverflowException.prototype.toString$0 = StackOverflowException.prototype.toString;
 // ********** Code for BadNumberFormatException **************
 function BadNumberFormatException(_s) {
   this._s = _s;
-  // Initializers done
 }
 BadNumberFormatException.prototype.toString = function() {
   return ("BadNumberFormatException: '" + this._s + "'");
 }
 BadNumberFormatException.prototype.toString$0 = BadNumberFormatException.prototype.toString;
 // ********** Code for NullPointerException **************
 function NullPointerException() {
-  // Initializers done
+
 }
 NullPointerException.prototype.toString = function() {
   return "NullPointerException";
 }
 NullPointerException.prototype.toString$0 = NullPointerException.prototype.toString;
 // ********** Code for NoMoreElementsException **************
 function NoMoreElementsException() {
-  // Initializers done
+
 }
 NoMoreElementsException.prototype.toString = function() {
   return "NoMoreElementsException";
 }
 NoMoreElementsException.prototype.toString$0 = NoMoreElementsException.prototype.toString;
 // ********** Code for EmptyQueueException **************
 function EmptyQueueException() {
-  // Initializers done
+
 }
 EmptyQueueException.prototype.toString = function() {
   return "EmptyQueueException";
 }
 EmptyQueueException.prototype.toString$0 = EmptyQueueException.prototype.toString;
 // ********** Code for dart_core_Function **************
 Function.prototype.to$call$0 = function() {
   this.call$0 = this._genStub(0);
   this.to$call$0 = function() { return this.call$0; };
   return this.call$0;
@@ skipping 191 matching lines @@
 ListFactory_Expression = ListFactory;
 ListFactory_K = ListFactory;
 ListFactory_dart_core_String = ListFactory;
 ListFactory_V = ListFactory;
 ListFactory_Value = ListFactory;
 ListFactory_int = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = (0);
-  // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.get$length() > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$7);
+    $throw(const$0005);
   }
   return this._array.$index(this._pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
 // ********** Code for ImmutableList **************
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }
 $inherits(ImmutableList, ListFactory_E);
 function ImmutableList(length) {
   this._length = length;
-  // Initializers done
   Array.call(this, length);
 }
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.get$length());
   for (var i = (0);
    i < other.get$length(); i++) {
     list._setindex(i, other.$index(i));
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
 }
 ImmutableList.prototype.set$length = function(length) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 Object.defineProperty(ImmutableList.prototype, "length", {
   get: ImmutableList.prototype.get$length,
   set: ImmutableList.prototype.set$length
 });
 ImmutableList.prototype._setindex = function(index, value) {
   return this[index] = value;
 }
 ImmutableList.prototype.$setindex = function(index, value) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.sort = function(compare) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.add = function(element) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.addLast = function(element) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.addAll = function(elements) {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.clear = function() {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.removeLast = function() {
-  $throw(const$126);
+  $throw(const$0007);
 }
 ImmutableList.prototype.toString = function() {
   return ListFactory.ListFactory$from$factory(this).toString();
 }
 ImmutableList.prototype.add$1 = ImmutableList.prototype.add;
 ImmutableList.prototype.addAll$1 = ImmutableList.prototype.addAll;
 ImmutableList.prototype.removeLast$0 = ImmutableList.prototype.removeLast;
 ImmutableList.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 ImmutableList.prototype.toString$0 = ImmutableList.prototype.toString;
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.isNaN = function() {
   'use strict'; return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   'use strict'; return this == 0 ? (1 / this) < 0 : this < 0;
 }
 NumImplementation.prototype.hashCode = function() {
   'use strict'; return this & 0x1FFFFFFF;
 }
-NumImplementation.prototype.toInt = function() {
-    'use strict';
-    if (isNaN(this)) $throw(new BadNumberFormatException("NaN"));
-    if ((this == Infinity) || (this == -Infinity)) {
-      $throw(new BadNumberFormatException("Infinity"));
-    }
-    var truncated = (this < 0) ? Math.ceil(this) : Math.floor(this);
-    if (truncated == -0.0) return 0;
-    return truncated;
-}
 NumImplementation.prototype.toDouble = function() {
   'use strict'; return this + 0;
 }
 NumImplementation.prototype.toRadixString = function(radix) {
   'use strict'; return this.toString(radix)
 }
 NumImplementation.prototype.compareTo = function(other) {
   var thisValue = this.toDouble();
   if (thisValue < other) {
     return (-1);
@@ skipping 16 matching lines @@
       return (0);
     }
     return (1);
   }
   else {
     return (-1);
   }
 }
 NumImplementation.prototype.compareTo$1 = NumImplementation.prototype.compareTo;
 NumImplementation.prototype.hashCode$0 = NumImplementation.prototype.hashCode;
-NumImplementation.prototype.toDouble$0 = NumImplementation.prototype.toDouble;
-NumImplementation.prototype.toInt$0 = NumImplementation.prototype.toInt;
 NumImplementation.prototype.toRadixString$1 = NumImplementation.prototype.toRadixString;
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
-  // Initializers done
   this._numberOfEntries = (0);
   this._numberOfDeleted = (0);
   this._loadLimit = HashMapImplementation._computeLoadLimit((8));
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation_K$V();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
@@ skipping 17 matching lines @@
   var insertionIndex = (-1);
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ((insertionIndex < (0)) && (const$2 == existingKey)) {
+    else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
@@ skipping 22 matching lines @@
 HashMapImplementation.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key == const$2) {
+    if (key == null || key == const$0001) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$2)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < (0)) return null;
   return this._values.$index(index);
 }
 HashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var index = this._probeForLookup(key);
   if (index >= (0)) return this._values.$index(index);
   var value = ifAbsent();
   this.$setindex(key, value);
   return value;
 }
 HashMapImplementation.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
   if (index >= (0)) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
-    this._keys.$setindex(index, const$2);
+    this._keys.$setindex(index, const$0001);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
 HashMapImplementation.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$2)) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
@@ skipping 15 matching lines @@
 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 **************
 $inherits(HashMapImplementation_E$E, HashMapImplementation);
 function HashMapImplementation_E$E() {
-  // Initializers done
   this._numberOfEntries = (0);
   this._numberOfDeleted = (0);
   this._loadLimit = HashMapImplementation._computeLoadLimit((8));
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 HashMapImplementation_E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation_E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - (1));
 }
 HashMapImplementation_E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation_E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   var insertionIndex = (-1);
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ((insertionIndex < (0)) && (const$2 == existingKey)) {
+    else if ((insertionIndex < (0)) && (const$0001 == existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
   var numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
@@ skipping 22 matching lines @@
 HashMapImplementation_E$E.prototype._grow = function(newCapacity) {
   var capacity = this._keys.get$length();
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new Array(newCapacity);
   this._values = new Array(newCapacity);
   for (var i = (0);
    i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key == const$2) {
+    if (key == null || key == const$0001) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = (0);
 }
 HashMapImplementation_E$E.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$2)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$0001)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation_E$E.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
   if (index >= (0)) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
-    this._keys.$setindex(index, const$2);
+    this._keys.$setindex(index, const$0001);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation_E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == (0);
 }
 HashMapImplementation_E$E.prototype.forEach = function(f) {
   var length = this._keys.get$length();
   for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$2)) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$0001)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation_E$E.prototype.getKeys = function() {
   var list = new Array(this.get$length());
   var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   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() {}
 // ********** Code for HashMapImplementation_K$V **************
 $inherits(HashMapImplementation_K$V, HashMapImplementation);
 function HashMapImplementation_K$V() {
-  // Initializers done
   this._numberOfEntries = (0);
   this._numberOfDeleted = (0);
   this._loadLimit = HashMapImplementation._computeLoadLimit((8));
   this._keys = new Array((8));
   this._values = new Array((8));
 }
 HashMapImplementation_K$V._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * (3)), (4));
 }
-// ********** Code for HashMapImplementation_dart_core_String$Value **************
-$inherits(HashMapImplementation_dart_core_String$Value, HashMapImplementation);
-function HashMapImplementation_dart_core_String$Value() {}
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
-  // Initializers done
   this._backingMap = new HashMapImplementation_E$E();
 }
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation_E();
   for (var $$i = other.iterator(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     set.add(e);
   }
   return set;
 }
@@ skipping 59 matching lines @@
   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() {
-  // Initializers done
   this._backingMap = new HashMapImplementation_E$E();
 }
 // ********** Code for HashSetImplementation_Library **************
 $inherits(HashSetImplementation_Library, HashSetImplementation);
 function HashSetImplementation_Library() {}
 // ********** Code for HashSetImplementation_dart_core_String **************
 $inherits(HashSetImplementation_dart_core_String, HashSetImplementation);
 function HashSetImplementation_dart_core_String() {}
 // ********** Code for HashSetImplementation_Type **************
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
+  this._entries = set_._backingMap._keys;
   this._nextValidIndex = (-1);
-  this._entries = set_._backingMap._keys;
-  // Initializers done
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.get$length()) return false;
-  if (this._entries.$index(this._nextValidIndex) == const$2) {
+  if (this._entries.$index(this._nextValidIndex) == const$0001) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.get$length();
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$7);
+    $throw(const$0005);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
-  var deletedKey = const$2;
+  var deletedKey = const$0001;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry == deletedKey))
 }
 HashSetIterator.prototype.hasNext$0 = HashSetIterator.prototype.hasNext;
 HashSetIterator.prototype.next$0 = HashSetIterator.prototype.next;
 // ********** Code for HashSetIterator_E **************
 $inherits(HashSetIterator_E, HashSetIterator);
 function HashSetIterator_E(set_) {
   this._nextValidIndex = (-1);
   this._entries = set_._backingMap._keys;
-  // Initializers done
   this._advance();
 }
 HashSetIterator_E.prototype._advance = function() {
   var length = this._entries.get$length();
   var entry;
-  var deletedKey = const$2;
+  var deletedKey = const$0001;
   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.value = 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
 }
 // ********** 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);
   }
   else {
     this._list.addLast(new KeyValuePair_K$V(key, value));
     this._map.$setindex(key, this._list.lastEntry());
@@ skipping 47 matching lines @@
 }
 LinkedHashMapImplementation.prototype.containsKey$1 = LinkedHashMapImplementation.prototype.containsKey;
 LinkedHashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 LinkedHashMapImplementation.prototype.getKeys$0 = LinkedHashMapImplementation.prototype.getKeys;
 LinkedHashMapImplementation.prototype.getValues$0 = LinkedHashMapImplementation.prototype.getValues;
 LinkedHashMapImplementation.prototype.isEmpty$0 = LinkedHashMapImplementation.prototype.isEmpty;
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
-  // Initializers done
   this._element = e;
 }
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 DoubleLinkedQueueEntry.prototype.prepend = function(e) {
   new DoubleLinkedQueueEntry_E(e)._link(this._previous, this);
@@ skipping 10 matching lines @@
 }
 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;
 }
 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;
 }
 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);
 }
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
-  $throw(const$1);
+  $throw(const$0000);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
-  $throw(const$1);
+  $throw(const$0000);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel_E **************
 $inherits(_DoubleLinkedQueueEntrySentinel_E, _DoubleLinkedQueueEntrySentinel);
 function _DoubleLinkedQueueEntrySentinel_E() {
-  // Initializers done
   DoubleLinkedQueueEntry_E.call(this, null);
   this._link(this, this);
 }
 // ********** 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);
 }
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
-  // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_E();
 }
 DoubleLinkedQueue.DoubleLinkedQueue$from$factory = function(other) {
   var list = new DoubleLinkedQueue();
   for (var $$i = other.iterator(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     list.addLast(e);
   }
   return list;
 }
@@ skipping 88 matching lines @@
 DoubleLinkedQueue.prototype.removeLast$0 = DoubleLinkedQueue.prototype.removeLast;
 DoubleLinkedQueue.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for DoubleLinkedQueue_E **************
 $inherits(DoubleLinkedQueue_E, DoubleLinkedQueue);
 function DoubleLinkedQueue_E() {}
 // ********** Code for DoubleLinkedQueue_KeyValuePair_K$V **************
 $inherits(DoubleLinkedQueue_KeyValuePair_K$V, DoubleLinkedQueue);
 function DoubleLinkedQueue_KeyValuePair_K$V() {
-  // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue_KeyValuePair_K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry != this._sentinel) {
     var nextEntry = entry._next;
     f(entry._element);
     entry = nextEntry;
   }
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
-  // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next != this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$7);
+    $throw(const$0005);
   }
   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;
 }
 // ********** 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();
   }
   else {
     if (this._stop == null) {
       return;
     }
     this._start = Clock.now() - (this._stop - this._start);
@@ skipping 16 matching lines @@
 }
 StopwatchImplementation.prototype.elapsedInMs = function() {
   return $truncdiv((this.elapsed() * (1000)), this.frequency());
 }
 StopwatchImplementation.prototype.frequency = function() {
   return Clock.frequency();
 }
 StopwatchImplementation.prototype.start$0 = StopwatchImplementation.prototype.start;
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
-  // Initializers done
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
 StringBufferImpl.prototype.isEmpty = function() {
   return this._length == (0);
 }
 StringBufferImpl.prototype.add = function(obj) {
@@ skipping 154 matching lines @@
     var e = $$i.next$0();
     if (f(e)) destination.add(e);
   }
   return destination;
 }
 // ********** Code for _Worker **************
 // ********** Code for _ArgumentMismatchException **************
 $inherits(_ArgumentMismatchException, ClosureArgumentMismatchException);
 function _ArgumentMismatchException(_message) {
   this._dart_coreimpl_message = _message;
-  // Initializers done
   ClosureArgumentMismatchException.call(this);
 }
 _ArgumentMismatchException.prototype.toString = function() {
   return ("Closure argument mismatch: " + this._dart_coreimpl_message);
 }
 _ArgumentMismatchException.prototype.toString$0 = _ArgumentMismatchException.prototype.toString;
 // ********** Code for _FunctionImplementation **************
 _FunctionImplementation = Function;
 _FunctionImplementation.prototype._genStub = function(argsLength, names) {
       // Fast path #1: if no named arguments and arg count matches
@@ skipping 56 matching lines @@
       // Note: using Function instead of 'eval' to get a clean scope.
       // TODO(jmesserly): evaluate the performance of these stubs.
       var f = 'function(' + a.join(',') + '){return $f(' + p.join(',') + ');}';
       return new Function('$f', 'return ' + f + '').call(null, this);
     
 }
 // ********** Code for top level **************
 //  ********** Library node **************
 // ********** Code for Process **************
 function Process(_process) {
-  this.SIGHUP = "SIGHUP"
-  this.SIGINT = "SIGINT"
-  this.SIGQUIT = "SIGQUIT"
-  this.SIGILL = "SIGILL"
-  this.SIGTRAP = "SIGTRAP"
-  this.SIGABRT = "SIGABRT"
-  this.SIGEMT = "SIGEMT"
-  this.SIGFPE = "SIGFPE"
-  this.SIGKILL = "SIGKILL"
-  this.SIGBUS = "SIGBUS"
-  this.SIGSEGV = "SIGSEGV"
-  this.SIGSYS = "SIGSYS"
-  this.SIGPIPE = "SIGPIPE"
-  this.SIGALRM = "SIGALRM"
-  this.SIGTERM = "SIGTERM"
-  this.SIGURG = "SIGURG"
-  this.SIGSTOP = "SIGSTOP"
-  this.SIGTSTP = "SIGTSTP"
-  this.SIGCONT = "SIGCONT"
-  this.SIGCHLD = "SIGCHLD"
-  this.SIGTTIN = "SIGTTIN"
-  this.SIGTTOU = "SIGTTOU"
-  this.SIGIO = "SIGIO"
-  this.SIGXCPU = "SIGXCPU"
-  this.SIGXFSZ = "SIGXFSZ"
-  this.SIGVTALRM = "SIGVTALRM"
-  this.SIGPROF = "SIGPROF"
-  this.SIGWINCH = "SIGWINCH"
-  this.SIGINFO = "SIGINFO"
-  this.SIGUSR1 = "SIGUSR1"
-  this.SIGUSR2 = "SIGUSR2"
+  this.SIGSYS = "SIGSYS";
+  this.SIGALRM = "SIGALRM";
+  this.SIGXCPU = "SIGXCPU";
+  this.SIGTSTP = "SIGTSTP";
+  this.SIGSEGV = "SIGSEGV";
+  this.SIGQUIT = "SIGQUIT";
+  this.SIGABRT = "SIGABRT";
+  this.SIGKILL = "SIGKILL";
+  this.SIGHUP = "SIGHUP";
+  this.SIGUSR2 = "SIGUSR2";
+  this.SIGXFSZ = "SIGXFSZ";
+  this.SIGCONT = "SIGCONT";
+  this.SIGTTOU = "SIGTTOU";
+  this.SIGINT = "SIGINT";
+  this.SIGURG = "SIGURG";
+  this.SIGFPE = "SIGFPE";
+  this.SIGUSR1 = "SIGUSR1";
+  this.SIGEMT = "SIGEMT";
+  this.SIGPIPE = "SIGPIPE";
+  this.SIGTTIN = "SIGTTIN";
+  this.SIGTERM = "SIGTERM";
   this._process = _process;
-  // Initializers done
+  this.SIGBUS = "SIGBUS";
+  this.SIGPROF = "SIGPROF";
+  this.SIGSTOP = "SIGSTOP";
+  this.SIGCHLD = "SIGCHLD";
+  this.SIGILL = "SIGILL";
+  this.SIGTRAP = "SIGTRAP";
+  this.SIGINFO = "SIGINFO";
+  this.SIGIO = "SIGIO";
+  this.SIGVTALRM = "SIGVTALRM";
+  this.SIGWINCH = "SIGWINCH";
 }
 Process.prototype.get$argv = function() {
   return this._process.argv;
 }
 Process.prototype.set$argv = function(value) {
   this._process.argv = value;
 }
 Process.prototype.get$env = function() {
   return new EnvMap(this._process);
 }
 Process.prototype.exit = function(code) {
   this._process.exit(code);
 }
 // ********** Code for EnvMap **************
 function EnvMap(_process) {
   this._process = _process;
-  // Initializers done
 }
 EnvMap.prototype.$index = function(key) {
   return this._process.env[key];
 }
 // ********** Code for ReadableStream **************
 // ********** Code for WritableStream **************
 Object.prototype.$typeNameOf = function() {
   if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')
       || typeof(process) != 'undefined') { // fast-path for Chrome and Node
     return this.constructor.name;
@@ skipping 114 matching lines @@
   if (lastSlash == (-1)) {
     return path;
   }
   else {
     return path.substring(lastSlash + (1));
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
-  // Initializers done
+
 }
 NodeFileSystem.prototype.writeString = function(outfile, text) {
   fs.writeFileSync(outfile, text);
 }
 NodeFileSystem.prototype.readAll = function(filename) {
   return fs.readFileSync(filename, "utf8");
 }
 NodeFileSystem.prototype.fileExists = function(filename) {
   return path.existsSync(filename);
 }
 // ********** Code for top level **************
 //  ********** Library lang **************
 // ********** Code for CodeWriter **************
 function CodeWriter() {
-  this._indentation = (0)
-  this._pendingIndent = false
-  this.writeComments = true
+  this._indentation = (0);
+  this.writeComments = true;
+  this._pendingIndent = false;
   this._buf = new StringBufferImpl("");
-  // Initializers done
 }
 CodeWriter.prototype.get$text = function() {
   return this._buf.toString();
 }
 CodeWriter.prototype._indent = function() {
   this._pendingIndent = false;
   for (var i = (0);
    i < this._indentation; i++) {
     this._buf.add("  ");
   }
@@ skipping 33 matching lines @@
   this._indentation--;
   this.writeln(text);
 }
 CodeWriter.prototype.nextBlock = function(text) {
   this._indentation--;
   this.writeln(text);
   this._indentation++;
 }
 // ********** Code for CoreJs **************
 function CoreJs() {
-  this.useThrow = false
-  this.useAssert = false
-  this.useNotNullBool = false
-  this.useIndex = false
-  this.useSetIndex = false
-  this.useWrap0 = false
-  this.useWrap1 = false
-  this.useIsolates = false
-  this._generatedTypeNameOf = false
-  this._generatedDynamicProto = false
-  this._generatedInherits = false
+  this.useAssert = false;
+  this.useIsolates = false;
+  this._generatedTypeNameOf = false;
   this._usedOperators = new HashMapImplementation();
+  this._generatedInherits = false;
+  this.useNotNullBool = false;
   this.writer = new CodeWriter();
-  // Initializers done
+  this.useWrap0 = false;
+  this.useThrow = false;
+  this._generatedDynamicProto = false;
+  this.useWrap1 = false;
+  this.useSetIndex = false;
+  this.useIndex = false;
 }
 CoreJs.prototype.useOperator = function(name) {
   if (this._usedOperators.$index(name) != null) return;
   var code;
   switch (name) {
     case ":ne":
 
       code = "function $ne(x, y) {\n  if (x == null) return y != null;\n  return (typeof(x) == 'number' && typeof(y) == 'number') ||\n         (typeof(x) == 'boolean' && typeof(y) == 'boolean') ||\n         (typeof(x) == 'string' && typeof(y) == 'string')\n    ? x != y : !x.$eq(y);\n}";
       break;
 
@@ skipping 95 matching lines @@
   if ($globals.world.dom != null) {
     this.ensureTypeNameOf();
     w.writeln("Object.prototype.get$typeName =  Object.prototype.$typeNameOf;");
   }
 }
 CoreJs.prototype.generate$1 = CoreJs.prototype.generate;
 // ********** Code for Element **************
 function Element(name, _enclosingElement) {
   this.name = name;
   this._enclosingElement = _enclosingElement;
-  // Initializers done
   this._jsname = $globals.world.toJsIdentifier(this.name);
 }
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.set$name = function(value) { return this.name = value; };
 Element.prototype.get$_jsname = function() { return this._jsname; };
 Element.prototype.set$_jsname = function(value) { return this._jsname = value; };
 Element.prototype.get$library = function() {
   return null;
 }
 Element.prototype.get$span = function() {
@@ skipping 83 matching lines @@
   }
   else {
     $globals.world.internalError("unknown type reference", node.span);
   }
   return node.type;
 }
 Element.prototype.hashCode$0 = Element.prototype.hashCode;
 Element.prototype.resolve$0 = Element.prototype.resolve;
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
-  this.hasStatics = false
   this.main = main;
+  this.hasStatics = false;
+  this.corejs = new CoreJs();
+  this.globals = new HashMapImplementation();
   this.writer = writer;
-  this.globals = new HashMapImplementation();
-  this.corejs = new CoreJs();
-  // Initializers done
 }
 WorldGenerator.prototype.run = function() {
   var metaGen = new MethodGenerator(this.main, null);
   var mainTarget = new Value.type$ctor(this.main.declaringType, this.main.get$span());
   var mainCall = this.main.invoke(metaGen, null, mainTarget, Arguments.get$EMPTY(), false);
   this.main.declaringType.markUsed();
   if ($globals.options.compileAll) {
     this.markLibrariesUsed([$globals.world.coreimpl, $globals.world.corelib, this.main.declaringType.get$library()]);
   }
   $globals.world.numImplType.markUsed();
@@ skipping 74 matching lines @@
   if (ret == null) {
     ret = new GlobalValue(exp.get$type(), exp.get$code(), field.isFinal, field, null, exp, exp.span, dependencies);
     this.globals.$setindex(key, ret);
   }
   return ret;
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var key = exp.get$type().get$jsname() + ":" + exp.get$code();
   var ret = this.globals.$index(key);
   if (ret == null) {
-    var name = ("const$" + this.globals.get$length());
+    var ns = this.globals.get$length().toString();
+    while (ns.get$length() < (4)) ns = "0" + ns;
+    var name = ("const$" + ns);
     ret = new GlobalValue(exp.get$type(), name, true, null, name, exp, exp.span, dependencies);
     this.globals.$setindex(key, ret);
   }
   return ret;
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if (lib.isWritten) return;
   lib.isWritten = true;
   var $$list = lib.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
@@ skipping 420 matching lines @@
   if (x.get$span() == null) return (1);
   if (y.get$span() == null) return (-1);
   return x.get$name().compareTo$1(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return this._compareMembers.bind(this);
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
+  this._vars = new HashMapImplementation();
   this.parent = parent;
   this.reentrant = reentrant;
-  this._vars = new HashMapImplementation();
   this._jsNames = new HashSetImplementation();
-  // Initializers done
   if (this.get$isMethodScope()) {
     this._closedOver = new HashSetImplementation();
   }
   else {
     this.reentrant = reentrant || this.parent.reentrant;
   }
 }
 BlockScope.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
 BlockScope.prototype.set$enclosingMethod = function(value) { return this.enclosingMethod = value; };
 BlockScope.prototype.get$parent = function() { return this.parent; };
@@ skipping 71 matching lines @@
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
   while (scope.get$rethrow() == null && scope.get$parent() != null) {
     scope = scope.get$parent();
   }
   return scope.get$rethrow();
 }
 // ********** Code for MethodGenerator **************
 function MethodGenerator(method, enclosingMethod) {
+  this.enclosingMethod = enclosingMethod;
+  this.needsThis = false;
   this.method = method;
-  this.enclosingMethod = enclosingMethod;
   this.writer = new CodeWriter();
-  this.needsThis = false;
-  // Initializers done
   if (this.enclosingMethod != null) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
@@ skipping 42 matching lines @@
     this._freeTemps.add(value.get$code());
   }
   else {
     $globals.world.internalError(("tried to free unused value or non-temp \"" + value.get$code() + "\""));
   }
 }
 MethodGenerator.prototype.run = function() {
   if (this.method.isGenerated) return;
   this.method.isGenerated = true;
   this.method.generator = this;
-  this.writeBody();
+  var thisObject;
+  if (this.method.get$isConstructor()) {
+    thisObject = new ObjectValue(false, this.method.declaringType, this.method.get$span());
+    thisObject.initFields$0();
+  }
+  else {
+    thisObject = new Value(this.method.declaringType, "this", null, true);
+  }
+  var values = [];
+  var $$list = this.method.get$parameters();
+  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
+    var p = $$list.$index($$i);
+    values.add$1(new Value(p.get$type(), p.get$name(), null, true));
+  }
+  var args = new Arguments(null, values);
+  this.evalBody(thisObject, args);
   if (this.method.get$definition().get$nativeBody() != null) {
     this.writer = new CodeWriter();
     if ($eq(this.method.get$definition().get$nativeBody(), "")) {
       this.method.generator = null;
     }
     else {
       this._paramCode = map(this.method.get$parameters(), (function (p) {
         return p.get$name();
       })
       );
@@ skipping 115 matching lines @@
         else {
           start = meth.declaringType.get$jsname() + ".prototype.";
         }
         optNames.addAll$1(optValues);
         var optional = "['" + Strings.join(optNames, "', '") + "']";
         defWriter.writeln(("" + start + meth.get$jsname() + ".$optional = " + optional));
       }
     }
   }
 }
-MethodGenerator.prototype.writeBody = function() {
-  var initializers = null;
-  var initializedFields = null;
-  var allMembers = null;
-  if (this.method.get$isConstructor()) {
-    initializers = [];
-    initializedFields = new HashSetImplementation();
-    allMembers = $globals.world.gen._orderValues(this.method.declaringType.getAllMembers());
-    for (var $$i = allMembers.iterator$0(); $$i.hasNext$0(); ) {
-      var f = $$i.next$0();
-      if (f.get$isField() && !f.get$isStatic()) {
-        var cv = f.computeValue$0();
-        if (cv != null) {
-          initializers.add$1(("this." + f.get$jsname() + " = " + cv.get$code()));
-          initializedFields.add$1(f.get$name());
-        }
+MethodGenerator.prototype._initField = function(newObject, name, value, span) {
+  var field = this.method.declaringType.getMember(name);
+  if (field == null) {
+    $globals.world.error("bad initializer - no matching field", span);
+  }
+  if (!field.get$isField()) {
+    $globals.world.error(("\"this." + name + "\" does not refer to a field"), span);
+  }
+  return newObject.setField(field, value, true);
+}
+MethodGenerator.prototype.evalBody = function(newObject, args) {
+  var fieldsSet = false;
+  if (this.method.get$isNative() && this.method.get$isConstructor() && (newObject instanceof ObjectValue)) {
+    newObject.get$dynamic().set$seenNativeInitializer(true);
+  }
+  this._paramCode = [];
+  for (var i = (0);
+   i < this.method.get$parameters().get$length(); i++) {
+    var p = this.method.get$parameters().$index(i);
+    var currentArg = null;
+    if (i < args.get$bareCount()) {
+      currentArg = args.values.$index(i);
+    }
+    else {
+      currentArg = args.getValue(p.get$name());
+      if (currentArg == null) {
+        p.genValue$2(this.method, this.method.generator);
+        currentArg = p.get$value();
       }
     }
-  }
-  this._paramCode = [];
-  var $$list = this.method.get$parameters();
-  for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-    var p = $$list.$index($$i);
-    if (initializers != null && p.get$isInitializer()) {
-      var field = this.method.declaringType.getMember(p.get$name());
-      if (field == null) {
-        $globals.world.error("bad this parameter - no matching field", p.get$definition().get$span());
-      }
-      if (!field.get$isField()) {
-        $globals.world.error(("\"this." + p.get$name() + "\" does not refer to a field"), p.get$definition().get$span());
-      }
-      var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false);
-      this._paramCode.add(paramValue.get$code());
-      initializers.add$1(("this." + field.get$jsname() + " = " + paramValue.get$code() + ";"));
-      initializedFields.add$1(p.get$name());
+    if (p.get$isInitializer()) {
+      this._paramCode.add(p.get$name());
+      fieldsSet = true;
+      this._initField(newObject, p.get$name(), currentArg, p.get$definition().get$span());
     }
     else {
       var paramValue = this._scope.declareParameter(p);
       this._paramCode.add(paramValue.get$code());
+      if (newObject != null && newObject.get$isConst()) {
+        this._scope._vars.$setindex(p.get$name(), currentArg);
+      }
     }
   }
-  var body = this.method.get$definition().get$body();
-  if (body == null && !this.method.get$isConstructor() && !this.method.get$isNative()) {
-    $globals.world.error(("unexpected empty body for " + this.method.name), this.method.get$definition().get$span());
-  }
   var initializerCall = null;
   var declaredInitializers = this.method.get$definition().get$initializers();
-  if (initializers != null) {
-    for (var $$i = initializers.iterator$0(); $$i.hasNext$0(); ) {
-      var i = $$i.next$0();
-      this.writer.writeln(i);
-    }
-    if (declaredInitializers != null) {
-      for (var $$i = declaredInitializers.iterator$0(); $$i.hasNext$0(); ) {
-        var init = $$i.next$0();
-        if ((init instanceof CallExpression)) {
-          if (initializerCall != null) {
-            $globals.world.error("only one initializer redirecting call is allowed", init.get$span());
-          }
-          initializerCall = init;
+  if (declaredInitializers != null) {
+    for (var $$i = declaredInitializers.iterator$0(); $$i.hasNext$0(); ) {
+      var init = $$i.next$0();
+      if ((init instanceof CallExpression)) {
+        if (initializerCall != null) {
+          $globals.world.error("only one initializer redirecting call is allowed", init.get$span());
         }
-        else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.get$op().get$kind()) == (0)) {
-          var left = init.get$x();
-          if (!((left instanceof DotExpression) && (left.get$self() instanceof ThisExpression) || (left instanceof VarExpression))) {
-            $globals.world.error("invalid left side of initializer", left.get$span());
-            continue;
-          }
-          var f = this.method.declaringType.getMember(left.get$name().get$name());
-          if (f == null) {
-            $globals.world.error("bad initializer - no matching field", left.get$span());
-            continue;
-          }
-          else if (!f.get$isField()) {
-            $globals.world.error(("\"" + left.get$name().get$name() + "\" does not refer to a field"), left.get$span());
-            continue;
-          }
-          initializedFields.add$1(f.get$name());
-          this.writer.writeln(("this." + f.get$jsname() + " = " + this.visitValue(init.get$y()).get$code() + ";"));
+        initializerCall = init;
+      }
+      else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.get$op().get$kind()) == (0)) {
+        var left = init.get$x();
+        if (!((left instanceof DotExpression) && (left.get$self() instanceof ThisExpression) || (left instanceof VarExpression))) {
+          $globals.world.error("invalid left side of initializer", left.get$span());
+          continue;
         }
-        else {
-          $globals.world.error("invalid initializer", init.get$span());
-        }
+        var initValue = this.visitValue(init.get$y());
+        fieldsSet = true;
+        this._initField(newObject, left.get$name().get$name(), initValue, left.get$span());
+      }
+      else {
+        $globals.world.error("invalid initializer", init.get$span());
       }
     }
-    this.writer.comment("// Initializers done");
   }
   if (this.method.get$isConstructor() && initializerCall == null && !this.method.get$isNative()) {
     var parentType = this.method.declaringType.get$parent();
     if (parentType != null && !parentType.get$isObject()) {
       initializerCall = new CallExpression(new SuperExpression(this.method.get$span()), [], this.method.get$span());
     }
   }
-  if (initializerCall != null) {
-    var target = this._writeInitializerCall(initializerCall);
-    if (!target.get$isSuper()) {
-      if (initializers.get$length() > (0)) {
-        var $$list = this.method.get$parameters();
-        for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-          var p = $$list.$index($$i);
-          if (p.get$isInitializer()) {
-            $globals.world.error("no initialization allowed on redirecting constructors", p.get$definition().get$span());
-            break;
-          }
-        }
-      }
-      if (declaredInitializers != null && declaredInitializers.get$length() > (1)) {
-        var init = $eq(declaredInitializers.$index((0)), initializerCall) ? declaredInitializers.$index((1)) : declaredInitializers.$index((0));
-        $globals.world.error("no initialization allowed on redirecting constructors", init.get$span());
-      }
-      initializedFields = null;
-    }
-  }
-  if (initializedFields != null) {
-    for (var $$i = allMembers.iterator$0(); $$i.hasNext$0(); ) {
-      var member = $$i.next$0();
-      if (member.get$isField() && member.get$isFinal() && !member.get$isStatic() && !this.method.get$isNative() && !initializedFields.contains$1(member.get$name())) {
-        $globals.world.error(("Field \"" + member.get$name() + "\" is final and was not initialized"), this.method.get$definition().get$span());
+  if (this.method.get$isConstructor() && (newObject instanceof ObjectValue)) {
+    var fields = newObject.get$dynamic().get$fields();
+    var $$list = fields.getKeys$0();
+    for (var $$i = fields.getKeys$0().iterator$0(); $$i.hasNext$0(); ) {
+      var field = $$i.next$0();
+      var value = fields.$index(field);
+      if (value != null) {
+        this.writer.writeln(("this." + field.get$jsname() + " = " + value.get$code() + ";"));
       }
     }
   }
-  this.visitStatementsInBlock(body);
+  if (initializerCall != null) {
+    this.evalInitializerCall(newObject, initializerCall, fieldsSet);
+  }
+  if (this.method.get$isConstructor() && newObject != null && newObject.get$isConst()) {
+    newObject.validateInitialized(this.method.get$span());
+  }
+  else if (this.method.get$isConstructor()) {
+    var fields = newObject.get$dynamic().get$fields();
+    var $$list = fields.getKeys$0();
+    for (var $$i = fields.getKeys$0().iterator$0(); $$i.hasNext$0(); ) {
+      var field = $$i.next$0();
+      var value = fields.$index(field);
+      if (value == null && field.get$isFinal() && $eq(field.get$declaringType(), this.method.declaringType) && !newObject.get$dynamic().get$seenNativeInitializer()) {
+        $globals.world.error(("uninitialized final field \"" + field.get$name() + "\""), field.get$span(), this.method.get$span());
+      }
+    }
+  }
+  var body = this.method.get$definition().get$body();
+  if (body == null) {
+    if (!this.method.get$isConstructor() && !this.method.get$isNative()) {
+      $globals.world.error(("unexpected empty body for " + this.method.name), this.method.get$definition().get$span());
+    }
+  }
+  else {
+    this.visitStatementsInBlock(body);
+  }
 }
-MethodGenerator.prototype._writeInitializerCall = function(node) {
+MethodGenerator.prototype.evalInitializerCall = function(newObject, node, fieldsSet) {
   var contructorName = "";
   var targetExp = node.target;
   if ((targetExp instanceof DotExpression)) {
     var dot = targetExp;
     targetExp = dot.self;
     contructorName = dot.name.name;
   }
+  var targetType = null;
   var target = null;
   if ((targetExp instanceof SuperExpression)) {
+    targetType = this.method.declaringType.get$parent();
     target = this._makeSuperValue(targetExp);
   }
   else if ((targetExp instanceof ThisExpression)) {
+    targetType = this.method.declaringType;
     target = this._makeThisValue(targetExp);
+    if (fieldsSet) {
+      $globals.world.error("no initialization allowed with redirecting constructor", node.span);
+    }
   }
   else {
     $globals.world.error("bad call in initializers", node.span);
   }
   target.set$allowDynamic(false);
-  var m = target.get$type().getConstructor$1(contructorName);
+  var m = targetType.getConstructor(contructorName);
   if (m == null) {
-    $globals.world.error(("no matching constructor for " + target.get$type().get$name()), node.span);
+    $globals.world.error(("no matching constructor for " + targetType.name), node.span);
   }
   this.method.set$initDelegate(m);
   var other = m;
   while (other != null) {
     if ($eq(other, this.method)) {
       $globals.world.error("initialization cycle", node.span);
       break;
     }
     other = other.get$initDelegate();
   }
+  var newArgs = this._makeArgs(node.arguments);
   $globals.world.gen.genMethod(m);
-  var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
-  if ($ne(target.get$type(), $globals.world.objectType)) {
-    this.writer.writeln(("" + value.get$code() + ";"));
+  m._evalConstConstructor$2(newObject, newArgs);
+  if (!newObject.isConst) {
+    var value = m.invoke$4(this, node, target, newArgs);
+    if ($ne(target.get$type(), $globals.world.objectType)) {
+      this.writer.writeln(("" + value.get$code() + ";"));
+    }
   }
-  return target;
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var args = [];
   var seenLabel = false;
   for (var $$i = 0;$$i < arguments.get$length(); $$i++) {
     var arg = arguments.$index($$i);
     if (arg.get$label() != null) {
       seenLabel = true;
     }
     else if (seenLabel) {
@@ skipping 698 matching lines @@
       if (value.get$type().get$isNum()) {
         return new Value(value.get$type(), ("" + node.op + value.get$code()), node.span, true);
       }
       else {
         var kind = ((16) == node.op.kind ? (42) : (43));
         var operand = new LiteralExpression(Value.fromInt((1), node.span), node.span);
         var assignValue = this._visitAssign(kind, node.self, operand, node, to$call$1(null), false);
         return new Value(assignValue.get$type(), ("(" + assignValue.get$code() + ")"), node.span, true);
       }
 
-    case (19):
-
-      if (value.get$type().get$isBool() && value.get$isConst()) {
-        var newVal = !value.get$actualValue();
-        return Value.fromBool(newVal, node.span);
-      }
-      else {
-        var newVal = value.convertTo$2(this, $globals.world.nonNullBool);
-        return new Value(newVal.get$type(), ("!" + newVal.get$code()), node.span, true);
-      }
-
-    case (42):
-
-      return value.convertTo$2(this, $globals.world.numType);
-
-    case (43):
-    case (18):
-
-      if (node.op.kind == (18)) {
-        return value.invoke$4(this, ":bit_not", node, Arguments.get$EMPTY());
-      }
-      else if (node.op.kind == (43)) {
-        return value.invoke$4(this, ":negate", node, Arguments.get$EMPTY());
-      }
-      else {
-        $globals.world.internalError(("unimplemented: unary " + node.op), node.span);
-      }
-      $throw(new FallThroughError());
-
-    default:
-
-      $globals.world.internalError(("unimplemented: " + node.op), node.span);
-
   }
+  return value.unop$3(node.op.kind, this, node);
 }
 MethodGenerator.prototype.visitDeclaredIdentifier = function(node) {
   $globals.world.error("Expected expression", node.span);
 }
 MethodGenerator.prototype.visitAwaitExpression = function(node) {
   $globals.world.internalError("Await expressions should have been eliminated before code generation", node.span);
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
@@ skipping 194 matching lines @@
     if (this._expressionNeedsParens(item)) {
       code = ("(" + code + ")");
     }
     if ($eq(items.get$length(), (0)) || ($ne(code, "''") && $ne(code, "\"\""))) {
       items.add$1(code);
     }
   }
   return new Value($globals.world.stringType, ("(" + Strings.join(items, " + ") + ")"), node.span, true);
 }
 MethodGenerator.prototype._checkNonStatic$1 = MethodGenerator.prototype._checkNonStatic;
+MethodGenerator.prototype.evalBody$2 = MethodGenerator.prototype.evalBody;
 MethodGenerator.prototype.visitBinaryExpression$1 = function($0) {
   return this.visitBinaryExpression($0, false);
 };
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 MethodGenerator.prototype.writeDefinition$2 = MethodGenerator.prototype.writeDefinition;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
-  // Initializers done
 }
 Arguments.Arguments$bare$factory = function(arity) {
   var values = [];
   for (var i = (0);
    i < arity; i++) {
     values.add$1(new Value($globals.world.varType, ("$" + i), null, false));
   }
   return new Arguments(null, values);
 }
 Arguments.get$EMPTY = function() {
@@ skipping 75 matching lines @@
     var name = this.getName(i);
     if (name == null) name = ("$" + i);
     result.add$1(new Value($globals.world.varType, name, null, false));
   }
   return new Arguments(this.nodes, result);
 }
 // ********** Code for LibraryImport **************
 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.baseSource = baseSource;
-  // Initializers done
+  this.isWritten = false;
   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();
 }
 Library.prototype.get$baseSource = function() { return this.baseSource; };
@@ skipping 233 matching lines @@
 Library.prototype.$eq = function(other) {
   return (other instanceof Library) && $eq(other.get$baseSource().get$filename(), this.baseSource.filename);
 }
 Library.prototype.findTypeByName$1 = Library.prototype.findTypeByName;
 Library.prototype.hashCode$0 = Library.prototype.hashCode;
 Library.prototype.resolve$0 = Library.prototype.resolve;
 Library.prototype.toString$0 = Library.prototype.toString;
 Library.prototype.visitSources$0 = Library.prototype.visitSources;
 // ********** Code for _LibraryVisitor **************
 function _LibraryVisitor(library) {
-  this.seenImport = false
-  this.seenSource = false
-  this.seenResource = false
-  this.isTop = true
   this.library = library;
-  // Initializers done
+  this.isTop = true;
+  this.seenSource = false;
+  this.seenResource = false;
+  this.seenImport = false;
   this.currentType = this.library.topType;
   this.sources = [];
 }
 _LibraryVisitor.prototype.get$library = function() { return this.library; };
 _LibraryVisitor.prototype.get$isTop = function() { return this.isTop; };
 _LibraryVisitor.prototype.set$isTop = function(value) { return this.isTop = value; };
 _LibraryVisitor.prototype.addSourceFromName = function(name, span) {
   var filename = this.library.makeFullPath(name);
   if ($eq(filename, this.library.baseSource.filename)) {
     $globals.world.error("library can not source itself", span);
@@ skipping 166 matching lines @@
 _LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
 _LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod$2(":call", node.func);
 }
 _LibraryVisitor.prototype.addSource$1 = _LibraryVisitor.prototype.addSource;
 // ********** Code for Parameter **************
 function Parameter(definition, method) {
-  this.isInitializer = false
+  this.method = method;
   this.definition = definition;
-  this.method = method;
-  // Initializers done
+  this.isInitializer = false;
 }
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 Parameter.prototype.get$method = function() { return this.method; };
 Parameter.prototype.set$method = function(value) { return this.method = value; };
 Parameter.prototype.get$name = function() { return this.name; };
 Parameter.prototype.set$name = function(value) { return this.name = value; };
 Parameter.prototype.get$type = function() { return this.type; };
 Parameter.prototype.set$type = function(value) { return this.type = value; };
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
@@ skipping 44 matching lines @@
 }
 Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
 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._providePropertySyntax = false
-  this._provideFieldSyntax = false
   this.isGenerated = false;
   this.declaringType = declaringType;
-  // Initializers done
+  this._provideFieldSyntax = false;
+  this._providePropertySyntax = false;
   Element.call(this, name, declaringType);
 }
 Member.prototype.get$declaringType = function() { return this.declaringType; };
 Member.prototype.get$isGenerated = function() { return this.isGenerated; };
 Member.prototype.set$isGenerated = function(value) { return this.isGenerated = value; };
 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();
 }
@@ skipping 118 matching lines @@
   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);
 }
 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() {
@@ skipping 32 matching lines @@
 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._computing = false
+  this.isNative = false;
   this.definition = definition;
+  this._computing = false;
   this.value = value;
-  this.isNative = false;
-  // Initializers done
   Member.call(this, name, declaringType);
 }
 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; };
@@ skipping 77 matching lines @@
     this._computedValue = this.value.visit(finalGen);
     if (!this._computedValue.get$isConst()) {
       if (this.isStatic) {
         $globals.world.error("non constant static field must be initialized in functions", this.value.span);
       }
       else {
         $globals.world.error("non constant field must be initialized in constructor", this.value.span);
       }
     }
     if (this.isStatic) {
-      this._computedValue = $globals.world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
+      if (this.isFinal && this._computedValue.get$isConst()) {
+        ;
+      }
+      else {
+        this._computedValue = $globals.world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
+      }
     }
     this._computing = false;
   }
   return this._computedValue;
 }
 FieldMember.prototype._get = function(context, node, target, isDynamic) {
   if (this.isNative && this.get$returnType() != null) {
     this.get$returnType().markUsed();
     if ((this.get$returnType() instanceof DefinedType)) {
       var defaultType = this.get$returnType().get$genericType().defaultType;
@@ skipping 44 matching lines @@
 };
 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) {
-  // Initializers done
   Member.call(this, name, declaringType);
 }
 PropertyMember.prototype.get$getter = function() { return this.getter; };
 PropertyMember.prototype.set$getter = function(value) { return this.getter = value; };
 PropertyMember.prototype.get$setter = function() { return this.setter; };
 PropertyMember.prototype.set$setter = function(value) { return this.setter = value; };
 PropertyMember.prototype.get$span = function() {
   return this.getter != null ? this.getter.get$span() : null;
 }
 PropertyMember.prototype.get$canGet = function() {
@@ skipping 95 matching lines @@
 };
 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.get$length(); $$i++) {
     var p = $$list.$index($$i);
     var newType = p.get$type().resolveTypeParams$1(declaringType);
     if ($ne(newType, p.get$type())) {
       this.parameters.add(p.copyWithNewType$2(this, newType));
     }
@@ skipping 86 matching lines @@
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
   return new Value(this.get$inferredResult(), ret.get$code(), node.span, true);
 }
 ConcreteMember.prototype._set = function(context, node, target, value, isDynamic) {
   var ret = this.baseMember._set(context, node, target, value, isDynamic);
   return new Value(this.returnType, ret.get$code(), node.span, true);
 }
+ConcreteMember.prototype._evalConstConstructor = function(newObject, args) {
+  return this.baseMember.get$dynamic()._evalConstConstructor$2(newObject, args);
+}
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.get$code();
   if (this.get$isConstructor()) {
     code = code.replaceFirst$2(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
   if ((this.baseMember instanceof MethodMember)) {
     this.declaringType.genMethod(this);
   }
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
+ConcreteMember.prototype._evalConstConstructor$2 = ConcreteMember.prototype._evalConstConstructor;
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
 ConcreteMember.prototype._get$3$isDynamic = ConcreteMember.prototype._get;
 ConcreteMember.prototype._get$4 = ConcreteMember.prototype._get;
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
 ConcreteMember.prototype._set$4$isDynamic = ConcreteMember.prototype._set;
 ConcreteMember.prototype._set$5 = ConcreteMember.prototype._set;
 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._provideOptionalParamInfo = false
+  this.isLambda = false;
+  this._provideOptionalParamInfo = false;
+  this.isFactory = false;
   this.definition = definition;
-  // Initializers done
+  this.isConst = false;
+  this.isAbstract = false;
+  this.isStatic = false;
   Member.call(this, name, declaringType);
 }
 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$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
@@ skipping 265 matching lines @@
   }
   if (this.isFactory) {
     return new Value(target.get$type(), ("" + this.get$generatedFactoryName() + "(" + argsString + ")"), node != null ? node.span : null, true);
   }
   if (this.isStatic) {
     if (this.declaringType.get$isTop()) {
       return new Value(this.get$inferredResult(), ("" + this.get$jsname() + "(" + argsString + ")"), node != null ? node.span : null, true);
     }
     return new Value(this.get$inferredResult(), ("" + this.declaringType.get$jsname() + "." + this.get$jsname() + "(" + argsString + ")"), node.span, true);
   }
-  var code = ("" + target.get$code() + "." + this.get$jsname() + "(" + argsString + ")");
   if (this.name == "get:typeName" && this.declaringType.get$library().get$isDom()) {
     $globals.world.gen.corejs.ensureTypeNameOf();
   }
+  var code = ("" + target.get$code() + "." + this.get$jsname() + "(" + argsString + ")");
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
   var ctor = this.get$constructorName();
   if (ctor != "") ctor = ("." + ctor + "$ctor");
+  var span = node != null ? node.span : target.span;
   if (!target.isType) {
     var code = ("" + this.declaringType.get$nativeName() + ctor + ".call(" + argsString + ")");
-    return new Value(target.get$type(), code, node.span, true);
+    return new Value(target.get$type(), code, span, true);
   }
   else {
-    var code = ("new " + this.declaringType.get$nativeName() + ctor + "(" + argsString + ")");
     if (this.isConst && (node instanceof NewExpression) && node.get$dynamic().get$isConst()) {
-      return this._invokeConstConstructor(node, code, target, args);
+      if (this.get$isNative() || this.declaringType.name == "JSSyntaxRegExp") {
+        var code = ("new " + this.declaringType.get$nativeName() + ctor + "(" + argsString + ")");
+        return $globals.world.gen.globalForConst(new Value(target.get$type(), code, span, true), [args.values]);
+      }
+      var newType = this.declaringType;
+      var newObject = new ObjectValue(true, newType, span);
+      newObject.initFields$0();
+      this._evalConstConstructor(newObject, args);
+      return $globals.world.gen.globalForConst(newObject, [args.values]);
     }
     else {
-      var span = node != null ? node.span : target.span;
+      var code = ("new " + this.declaringType.get$nativeName() + ctor + "(" + argsString + ")");
       return new Value(target.get$type(), code, span, true);
     }
   }
 }
-MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
-  var fields = new HashMapImplementation();
-  for (var i = (0);
-   i < this.parameters.get$length(); i++) {
-    var param = this.parameters.$index(i);
-    if (param.get$isInitializer()) {
-      var value = null;
-      if (i < args.get$length()) {
-        value = args.values.$index(i);
-      }
-      else {
-        value = args.getValue(param.get$name());
-        if (value == null) {
-          value = param.get$value();
-        }
-      }
-      fields.$setindex(param.get$name(), value.get$constValue());
-    }
-  }
-  if (this.definition.initializers != null) {
-    this.generator._pushBlock(false);
-    for (var j = (0);
-     j < this.definition.formals.get$length(); j++) {
-      var name = this.definition.formals.$index(j).get$name().get$name();
-      var value = null;
-      if (j < args.get$length()) {
-        value = args.values.$index(j);
-      }
-      else {
-        value = args.getValue(this.parameters.$index(j).get$name());
-        if (value == null) {
-          value = this.parameters.$index(j).get$value();
-        }
-      }
-      this.generator._scope._vars.$setindex(name, value);
-    }
-    var $$list = this.definition.initializers;
-    for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
-      var init = $$list.$index($$i);
-      if ((init instanceof CallExpression)) {
-        var delegateArgs = this.generator._makeArgs(init.get$arguments());
-        var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
-        if ((init.get$target() instanceof ThisExpression)) {
-          return value;
-        }
-        else {
-          value = value.get$constValue();
-          var $list0 = value.get$fields().getKeys$0();
-          for (var $i0 = value.get$fields().getKeys$0().iterator$0(); $i0.hasNext$0(); ) {
-            var fname = $i0.next$0();
-            fields.$setindex(fname, value.get$fields().$index(fname));
-          }
-        }
-      }
-      else {
-        var assign = init;
-        var x = assign.x;
-        var fname = x.get$name().get$name();
-        var val = this.generator.visitValue(assign.y);
-        if (!val.get$isConst()) {
-          $globals.world.error("invalid non-const initializer in const constructor", assign.y.span);
-        }
-        fields.$setindex(fname, val);
-      }
-    }
-    this.generator._popBlock();
-  }
-  var $$list = this.declaringType.get$members().getValues();
-  for (var $$i = this.declaringType.get$members().getValues().iterator$0(); $$i.hasNext$0(); ) {
-    var f = $$i.next$0();
-    if ((f instanceof FieldMember) && !f.get$isStatic() && !fields.containsKey(f.get$name())) {
-      if (!f.get$isFinal()) {
-        $globals.world.error(("const class \"" + this.declaringType.name + "\" has non-final ") + ("field \"" + f.get$name() + "\""), f.get$span());
-      }
-      if (f.get$value() != null) {
-        fields.$setindex(f.get$name(), f.computeValue$0());
-      }
-    }
-  }
-  return $globals.world.gen.globalForConst(new ObjectValue(fields, true, target.get$type(), code, node.span), args.values);
+MethodMember.prototype._evalConstConstructor = function(newObject, args) {
+  this.declaringType.markUsed();
+  var generator = new MethodGenerator(this, null);
+  generator.evalBody$2(newObject, args);
 }
 MethodMember.prototype._invokeBuiltin = function(context, node, target, args, argsCode, isDynamic) {
-  var allConst = target.get$isConst() && args.values.every((function (arg) {
-    return arg.get$isConst();
-  })
-  );
   if (this.declaringType.get$isNum()) {
-    if (!allConst) {
-      var code;
-      if (this.name == ":negate") {
-        code = ("-" + target.get$code());
-      }
-      else if (this.name == ":bit_not") {
-        code = ("~" + target.get$code());
-      }
-      else if (this.name == ":truncdiv" || this.name == ":mod") {
-        $globals.world.gen.corejs.useOperator(this.name);
-        code = ("" + this.get$jsname() + "(" + target.get$code() + ", " + argsCode.$index((0)) + ")");
-      }
-      else {
-        var op = TokenKind.rawOperatorFromMethod(this.name);
-        code = ("" + target.get$code() + " " + op + " " + argsCode.$index((0)));
-      }
-      return new Value(this.get$inferredResult(), code, node.span, true);
+    var code;
+    if (this.name == ":negate") {
+      code = ("-" + target.get$code());
+    }
+    else if (this.name == ":bit_not") {
+      code = ("~" + target.get$code());
+    }
+    else if (this.name == ":truncdiv" || this.name == ":mod") {
+      $globals.world.gen.corejs.useOperator(this.name);
+      code = ("" + this.get$jsname() + "(" + target.get$code() + ", " + argsCode.$index((0)) + ")");
     }
     else {
-      var value;
-      var val0, val1, ival0, ival1;
-      val0 = target.get$dynamic().get$actualValue();
-      ival0 = val0.toInt();
-      if (args.values.get$length() > (0)) {
-        val1 = args.values.$index((0)).get$dynamic().get$actualValue();
-        ival1 = val1.toInt();
-      }
-      switch (this.name) {
-        case ":negate":
-
-          value = -val0;
-          break;
-
-        case ":add":
-
-          value = val0 + val1;
-          break;
-
-        case ":sub":
-
-          value = val0 - val1;
-          break;
-
-        case ":mul":
-
-          value = val0 * val1;
-          break;
-
-        case ":div":
-
-          value = val0 / val1;
-          break;
-
-        case ":truncdiv":
-
-          value = $truncdiv(val0, val1);
-          break;
-
-        case ":mod":
-
-          value = $mod(val0, val1);
-          break;
-
-        case ":eq":
-
-          value = val0 == val1;
-          break;
-
-        case ":lt":
-
-          value = val0 < val1;
-          break;
-
-        case ":gt":
-
-          value = val0 > val1;
-          break;
-
-        case ":lte":
-
-          value = val0 <= val1;
-          break;
-
-        case ":gte":
-
-          value = val0 >= val1;
-          break;
-
-        case ":ne":
-
-          value = val0 != val1;
-          break;
-
-        case ":bit_not":
-
-          value = (~ival0).toDouble();
-          break;
-
-        case ":bit_or":
-
-          value = (ival0 | ival1).toDouble();
-          break;
-
-        case ":bit_xor":
-
-          value = (ival0 ^ ival1).toDouble();
-          break;
-
-        case ":bit_and":
-
-          value = (ival0 & ival1).toDouble();
-          break;
-
-        case ":shl":
-
-          value = (ival0 << ival1).toDouble();
-          break;
-
-        case ":sar":
-
-          value = (ival0 >> ival1).toDouble();
-          break;
-
-        case ":shr":
-
-          value = (ival0 >>> ival1).toDouble();
-          break;
-
-      }
-      if (this.get$inferredResult().get$isInt()) {
-        return Value.fromInt(value.toInt$0(), node.span);
-      }
-      else if (this.get$inferredResult().get$isDouble()) {
-        return Value.fromDouble(value.toDouble$0(), node.span);
-      }
-      else if (this.get$inferredResult().get$isNum()) {
-        return Value.fromDouble(value.toDouble$0(), node.span);
-      }
-      else if (this.get$inferredResult().get$isBool()) {
-        return Value.fromBool(value, node.span);
-      }
-      else {
-        $globals.world.internalError(("unsupported const result type \"" + this.get$inferredResult().name + "\""), node.span);
-      }
+      var op = TokenKind.rawOperatorFromMethod(this.name);
+      code = ("" + target.get$code() + " " + op + " " + argsCode.$index((0)));
     }
+    return new Value(this.get$inferredResult(), code, node.span, true);
   }
   else if (this.declaringType.get$isString()) {
     if (this.name == ":index") {
       return new Value(this.declaringType, ("" + target.get$code() + "[" + argsCode.$index((0)) + "]"), node.span, true);
     }
     else if (this.name == ":add") {
-      if (allConst) {
-        var value = target.get$dynamic().get$actualValue() + args.values.$index((0)).get$dynamic().get$actualValue();
-        return Value.fromString(value, node.span);
-      }
       return new Value(this.declaringType, ("" + target.get$code() + " + " + argsCode.$index((0))), node.span, true);
     }
   }
   else if (this.declaringType.get$isNative()) {
     if (this.name == ":index") {
       return new Value(this.returnType, ("" + target.get$code() + "[" + argsCode.$index((0)) + "]"), node.span, true);
     }
     else if (this.name == ":setindex") {
       return new Value(this.returnType, ("" + target.get$code() + "[" + argsCode.$index((0)) + "] = " + argsCode.$index((1))), node.span, true);
     }
   }
   if (this.name == ":eq" || this.name == ":ne") {
     var op = this.name == ":eq" ? "==" : "!=";
     if (this.name == ":ne") {
       target.invoke(context, ":eq", node, args, isDynamic);
     }
-    if (allConst) {
-      var val0 = target.get$dynamic().get$actualValue();
-      var val1 = args.values.$index((0)).get$dynamic().get$actualValue();
-      var newVal = this.name == ":eq" ? $eq(val0, val1) : $ne(val0, val1);
-      return Value.fromBool(newVal, node.span);
-    }
     if ($eq(argsCode.$index((0)), "null")) {
       return new Value(this.get$inferredResult(), ("" + target.get$code() + " " + op + " null"), node.span, true);
     }
     else if (target.get$type().get$isNum() || target.get$type().get$isString()) {
       return new Value(this.get$inferredResult(), ("" + target.get$code() + " " + op + " " + argsCode.$index((0))), node.span, true);
     }
     $globals.world.gen.corejs.useOperator(this.name);
     return new Value(this.get$inferredResult(), ("" + this.get$jsname() + "(" + target.get$code() + ", " + argsCode.$index((0)) + ")"), node.span, true);
   }
   if (this.get$isCallMethod()) {
@@ skipping 21 matching lines @@
       if ($eq(mod.get$kind(), (84))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
       else if (this.get$isConstructor() && $eq(mod.get$kind(), (91))) {
         if (this.isConst) {
           $globals.world.error("duplicate const modifier", mod.get$span());
         }
+        if (this.isFactory) {
+          $globals.world.error("const factory not allowed", mod.get$span());
+        }
         this.isConst = true;
       }
       else if ($eq(mod.get$kind(), (73))) {
         if (this.isFactory) {
           $globals.world.error("duplicate factory modifier", mod.get$span());
         }
+        if (this.isConst) {
+          $globals.world.error("const factory not allowed", mod.get$span());
+        }
+        if (this.isStatic) {
+          $globals.world.error("static factory not allowed", mod.get$span());
+        }
         this.isFactory = true;
       }
       else if ($eq(mod.get$kind(), (71))) {
         if (this.isAbstract) {
           if (this.declaringType.get$isClass()) {
             $globals.world.error("duplicate abstract modifier", mod.get$span());
           }
           else if (!this.get$isCallMethod()) {
             $globals.world.error("abstract modifier not allowed on interface members", mod.get$span());
           }
@@ skipping 42 matching lines @@
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.resolveType = function(node, typeErrors) {
   var t = Element.prototype.resolveType.call(this, node, typeErrors);
   if (this.isStatic && !this.isFactory && (t instanceof ParameterType)) {
     $globals.world.error("using type parameter in static context.", node.span);
   }
   return t;
 }
+MethodMember.prototype._evalConstConstructor$2 = MethodMember.prototype._evalConstConstructor;
 MethodMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
 MethodMember.prototype._get$3$isDynamic = MethodMember.prototype._get;
 MethodMember.prototype._get$4 = MethodMember.prototype._get;
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
 MethodMember.prototype._set$4$isDynamic = MethodMember.prototype._set;
 MethodMember.prototype._set$5 = MethodMember.prototype._set;
 MethodMember.prototype.canInvoke$2 = MethodMember.prototype.canInvoke;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 MethodMember.prototype.invoke$4$isDynamic = MethodMember.prototype.invoke;
 MethodMember.prototype.invoke$5 = MethodMember.prototype.invoke;
 MethodMember.prototype.namesInOrder$1 = MethodMember.prototype.namesInOrder;
 MethodMember.prototype.provideFieldSyntax$0 = MethodMember.prototype.provideFieldSyntax;
 MethodMember.prototype.providePropertySyntax$0 = MethodMember.prototype.providePropertySyntax;
 MethodMember.prototype.resolve$0 = MethodMember.prototype.resolve;
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
+  this.jsname = member.get$jsname();
   this.name = member.name;
+  this.isVar = isVar;
   this.members = [member];
-  this.jsname = member.get$jsname();
-  this.isVar = isVar;
-  // Initializers done
 }
 MemberSet.prototype.get$name = function() { return this.name; };
 MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
 MemberSet.prototype.get$isVar = function() { return this.isVar; };
 MemberSet.prototype.toString = function() {
   return ("" + this.name + ":" + this.members.get$length());
 }
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
@@ skipping 232 matching lines @@
 MemberSet.prototype.canInvoke$2 = MemberSet.prototype.canInvoke;
 MemberSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 MemberSet.prototype.invoke$4$isDynamic = MemberSet.prototype.invoke;
 MemberSet.prototype.invoke$5 = MemberSet.prototype.invoke;
 MemberSet.prototype.toString$0 = MemberSet.prototype.toString;
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = new HashMapImplementation();
-  // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
   var ret = this.factories.$index(typeName);
   if (ret == null) {
     ret = new HashMapImplementation();
     this.factories.$setindex(typeName, ret);
   }
   return ret;
 }
 FactoryMap.prototype.addFactory = function(typeName, name, member) {
@@ skipping 10 matching lines @@
     );
   })
   );
 }
 FactoryMap.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FactoryMap.prototype.getFactory$2 = FactoryMap.prototype.getFactory;
 // ********** Code for Token **************
 function Token(kind, source, start, end) {
+  this.end = end;
   this.kind = kind;
+  this.start = start;
   this.source = source;
-  this.start = start;
-  this.end = end;
-  // Initializers done
 }
 Token.prototype.get$kind = function() { return this.kind; };
 Token.prototype.get$end = function() { return this.end; };
 Token.prototype.get$start = function() { return this.start; };
 Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
@@ skipping 14 matching lines @@
   return this.end.call$0();
 };
 Token.prototype.start$0 = function() {
   return this.start.call$0();
 };
 Token.prototype.toString$0 = Token.prototype.toString;
 // ********** Code for LiteralToken **************
 $inherits(LiteralToken, Token);
 function LiteralToken(kind, source, start, end, value) {
   this.value = value;
-  // Initializers done
   Token.call(this, kind, source, start, end);
 }
 LiteralToken.prototype.get$value = function() { return this.value; };
 LiteralToken.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for ErrorToken **************
 $inherits(ErrorToken, Token);
 function ErrorToken(kind, source, start, end, message) {
   this.message = message;
-  // Initializers done
   Token.call(this, kind, source, start, end);
 }
 ErrorToken.prototype.get$message = function() { return this.message; };
 ErrorToken.prototype.set$message = function(value) { return this.message = value; };
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
+  this._text = _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; };
 SourceFile.prototype.set$orderInLibrary = function(value) { return this.orderInLibrary = value; };
 SourceFile.prototype.get$text = function() {
   return this._text;
 }
 SourceFile.prototype.get$lineStarts = function() {
   if (this._lineStarts == null) {
     var starts = [(0)];
@@ skipping 64 matching lines @@
   }
 }
 SourceFile.prototype.compareTo$1 = SourceFile.prototype.compareTo;
 SourceFile.prototype.getColumn$2 = SourceFile.prototype.getColumn;
 SourceFile.prototype.getLine$1 = SourceFile.prototype.getLine;
 // ********** Code for SourceSpan **************
 function SourceSpan(file, start, end) {
   this.file = file;
   this.start = start;
   this.end = end;
-  // Initializers done
 }
 SourceSpan.prototype.get$file = function() { return this.file; };
 SourceSpan.prototype.get$start = function() { return this.start; };
 SourceSpan.prototype.get$end = function() { return this.end; };
 SourceSpan.prototype.get$text = function() {
   return this.file.get$text().substring(this.start, this.end);
 }
 SourceSpan.prototype.toMessageString = function(message) {
   return this.file.getLocationMessage(message, this.start, this.end, true);
 }
@@ skipping 11 matching lines @@
 }
 SourceSpan.prototype.compareTo$1 = SourceSpan.prototype.compareTo;
 SourceSpan.prototype.end$0 = function() {
   return this.end.call$0();
 };
 SourceSpan.prototype.start$0 = function() {
   return this.start.call$0();
 };
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
-  this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = (-1);
-  // Initializers done
+  this.previous = previous;
 }
 InterpStack.prototype.get$previous = function() { return this.previous; };
 InterpStack.prototype.set$previous = function(value) { return this.previous = value; };
 InterpStack.prototype.get$quote = function() { return this.quote; };
 InterpStack.prototype.get$isMultiline = function() { return this.isMultiline; };
 InterpStack.prototype.get$depth = function() { return this.depth; };
 InterpStack.prototype.set$depth = function(value) { return this.depth = value; };
 InterpStack.prototype.pop = function() {
   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.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._lang_index = index;
+  this._skipWhitespace = _skipWhitespace;
   this._source = _source;
-  this._skipWhitespace = _skipWhitespace;
-  this._lang_index = index;
-  // Initializers done
   TokenizerHelpers.call(this);
   this._text = this._source.get$text();
 }
 TokenizerBase.prototype._nextChar = function() {
   if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return (0);
   }
@@ skipping 421 matching lines @@
     return this._finishToken((70));
   }
   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);
 }
 Tokenizer.prototype.next = function() {
   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());
     }
@@ skipping 1332 matching lines @@
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == (20)) return (0);
   if (kind > (20) && kind <= (32)) {
     return kind + (15);
   }
   return (-1);
 }
 // ********** Code for Parser **************
 function Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
-  this._inhibitLambda = false
-  this._afterParensIndex = (0)
-  this._recover = false
+  this.throwOnIncomplete = throwOnIncomplete;
   this.source = source;
+  this.optionalSemicolons = optionalSemicolons;
+  this._recover = false;
+  this._inhibitLambda = false;
   this.diet = diet;
-  this.throwOnIncomplete = throwOnIncomplete;
-  this.optionalSemicolons = optionalSemicolons;
-  // Initializers done
+  this._afterParensIndex = (0);
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._afterParens = [];
 }
 Parser.prototype.get$enableAwait = function() {
   return $globals.experimentalAwaitPhase != null;
 }
 Parser.prototype.isPrematureEndOfFile = function() {
   if (this.throwOnIncomplete && this._maybeEat((1))) {
     $throw(new IncompleteSourceException(this._previousToken));
@@ skipping 803 matching lines @@
   if (!this._maybeEat((3))) {
     do {
       args.add$1(this.argument());
     }
     while (this._maybeEat((11)))
     this._eat((3));
   }
   this._inhibitLambda = saved;
   return args;
 }
-Parser.prototype.get$arguments = function() {
-  return this.arguments.bind(this);
-}
 Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case (2):
 
       return this.finishCallOrLambdaExpression(expr);
 
     case (4):
 
       this._eat((4));
       var index = this.expression();
@@ skipping 655 matching lines @@
   }
   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._lang_pos = (0)
+  this.parser = parser;
+  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._lang_pos);
   ++this._lang_pos;
   if (this._lang_pos == this.tokens.get$length()) {
     this.parser.tokenizer = this.previousTokenizer;
   }
   return token;
 }
 DivertedTokenSource.prototype.next$0 = DivertedTokenSource.prototype.next;
 // ********** Code for Node **************
 function Node(span) {
   this.span = span;
-  // 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);
 }
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
 Definition.prototype.get$nativeType = function() {
   return null;
 }
 // ********** Code for Expression **************
 $inherits(Expression, Node);
 function Expression(span) {
-  // Initializers done
   Node.call(this, span);
 }
 // ********** Code for TypeReference **************
 $inherits(TypeReference, Node);
 function TypeReference(span, type) {
   this.type = type;
-  // Initializers done
   Node.call(this, span);
 }
 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.arguments = arguments;
   this.name = name;
-  this.arguments = arguments;
-  // Initializers done
   Definition.call(this, span);
 }
 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, defaultType, body, span) {
+  this.extendsTypes = extendsTypes;
   this.isClass = isClass;
   this.name = name;
+  this.body = body;
   this.typeParameters = typeParameters;
-  this.extendsTypes = extendsTypes;
+  this.nativeType = nativeType;
   this.implementsTypes = implementsTypes;
-  this.nativeType = nativeType;
   this.defaultType = defaultType;
-  this.body = body;
-  // Initializers done
   Definition.call(this, span);
 }
 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.typeParameters = typeParameters;
   this.func = func;
-  this.typeParameters = typeParameters;
-  // Initializers done
   Definition.call(this, span);
 }
 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);
 }
 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.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, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
+  this.name = name;
+  this.initializers = initializers;
+  this.body = body;
   this.returnType = returnType;
-  this.name = name;
   this.formals = formals;
-  this.initializers = initializers;
   this.nativeBody = nativeBody;
-  this.body = body;
-  // Initializers done
   Definition.call(this, span);
 }
 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$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);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 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.falseBranch = falseBranch;
   this.trueBranch = trueBranch;
-  this.falseBranch = falseBranch;
-  // Initializers done
   Statement.call(this, span);
 }
 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.body = body;
   this.test = test;
-  this.body = body;
-  // Initializers done
   Statement.call(this, span);
 }
 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);
 }
 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.body = body;
   this.test = test;
   this.step = step;
-  this.body = body;
-  // Initializers done
+  this.init = init;
   Statement.call(this, span);
 }
 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.body = body;
   this.item = item;
   this.list = list;
-  this.body = body;
-  // Initializers done
   Statement.call(this, span);
 }
 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.finallyBlock = finallyBlock;
   this.catches = catches;
-  this.finallyBlock = finallyBlock;
-  // Initializers done
   Statement.call(this, span);
 }
 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);
 }
 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);
 }
 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.body = body;
   this.name = name;
-  this.body = body;
-  // Initializers done
   Statement.call(this, span);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
-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);
 }
-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.y = y;
+  this.x = x;
   this.op = op;
-  this.x = x;
-  this.y = y;
-  // Initializers done
   Expression.call(this, span);
 }
 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.self = self;
   this.op = op;
-  this.self = self;
-  // Initializers done
   Expression.call(this, span);
 }
 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);
 }
 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.arguments = arguments;
+  this.name = name;
+  this.type = type;
   this.isConst = isConst;
-  this.type = type;
-  this.name = name;
-  this.arguments = arguments;
-  // Initializers done
   Expression.call(this, span);
 }
 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, itemType, values, span) {
+  this.itemType = itemType;
   this.isConst = isConst;
-  this.itemType = itemType;
   this.values = values;
-  // Initializers done
   Expression.call(this, span);
 }
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = 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, keyType, valueType, items, span) {
-  this.isConst = isConst;
   this.keyType = keyType;
   this.valueType = valueType;
   this.items = items;
-  // Initializers done
+  this.isConst = isConst;
   Expression.call(this, span);
 }
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = 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.falseBranch = falseBranch;
   this.trueBranch = trueBranch;
-  this.falseBranch = falseBranch;
-  // Initializers done
   Expression.call(this, span);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 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);
 }
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 SuperExpression.prototype.visit$1 = SuperExpression.prototype.visit;
 // ********** Code for LiteralExpression **************
 $inherits(LiteralExpression, Expression);
 function LiteralExpression(value, span) {
   this.value = value;
-  // Initializers done
   Expression.call(this, span);
 }
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 LiteralExpression.prototype.visit$1 = LiteralExpression.prototype.visit;
 // ********** Code for StringInterpExpression **************
 $inherits(StringInterpExpression, Expression);
 function StringInterpExpression(pieces, span) {
   this.pieces = pieces;
-  // Initializers done
   Expression.call(this, span);
 }
 StringInterpExpression.prototype.visit = function(visitor) {
   return visitor.visitStringInterpExpression(this);
 }
 StringInterpExpression.prototype.visit$1 = StringInterpExpression.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
+  this.isFinal = isFinal;
   TypeReference.call(this, span);
 }
 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.depth = depth;
   this.baseType = baseType;
   this.typeArguments = typeArguments;
-  this.depth = depth;
-  // Initializers done
   TypeReference.call(this, span);
 }
 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.func = func;
   this.isFinal = isFinal;
-  this.func = func;
-  // Initializers done
   TypeReference.call(this, span);
 }
 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 DefaultTypeReference **************
 $inherits(DefaultTypeReference, TypeReference);
 function DefaultTypeReference(oldFactory, baseType, typeParameters, span) {
+  this.typeParameters = typeParameters;
   this.oldFactory = oldFactory;
   this.baseType = baseType;
-  this.typeParameters = typeParameters;
-  // Initializers done
   TypeReference.call(this, span);
 }
 DefaultTypeReference.prototype.get$baseType = function() { return this.baseType; };
 DefaultTypeReference.prototype.set$baseType = function(value) { return this.baseType = value; };
 DefaultTypeReference.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefaultTypeReference.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 DefaultTypeReference.prototype.visit = function(visitor) {
   return visitor.visitDefaultTypeReference(this);
 }
 DefaultTypeReference.prototype.visit$1 = DefaultTypeReference.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);
 }
 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.name = name;
   this.isThis = isThis;
+  this.type = type;
   this.isRest = isRest;
-  this.type = type;
-  this.name = name;
   this.value = value;
-  // Initializers done
   Node.call(this, span);
 }
 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.body = body;
   this.exception = exception;
   this.trace = trace;
-  this.body = body;
-  // Initializers done
   Node.call(this, span);
 }
 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.statements = statements;
   this.cases = cases;
-  this.statements = statements;
-  // Initializers done
   Node.call(this, span);
 }
 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.extendsType = extendsType;
   this.name = name;
-  this.extendsType = extendsType;
-  // Initializers done
   Node.call(this, span);
 }
 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);
 }
 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.name = name;
   this.type = type;
-  this.name = name;
-  // Initializers done
   Expression.call(this, span);
 }
 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.isTested = false;
   this._resolvedMembers = new HashMapImplementation();
+  this.isChecked = false;
+  this.isWritten = false;
   this.varStubs = new HashMapImplementation();
-  // Initializers done
   Element.call(this, name, null);
 }
 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 25 matching lines @@
 }
 Type.prototype.get$isFunction = function() {
   return false;
 }
 Type.prototype.get$isList = function() {
   return false;
 }
 Type.prototype.get$isNum = function() {
   return false;
 }
-Type.prototype.get$isInt = function() {
-  return false;
-}
-Type.prototype.get$isDouble = function() {
-  return false;
-}
 Type.prototype.get$isVoid = function() {
   return false;
 }
 Type.prototype.get$isNullable = function() {
   return true;
 }
 Type.prototype.get$isVarOrFunction = function() {
   return this.get$isVar() || this.get$isFunction();
 }
 Type.prototype.get$isVarOrObject = function() {
@@ skipping 277 matching lines @@
 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);
 }
 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() {
@@ skipping 40 matching lines @@
 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);
 }
 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() {
@@ skipping 90 matching lines @@
 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.isUsed = false;
+  this.constructors = new HashMapImplementation();
   this.genericType = genericType;
+  this.factories = new FactoryMap();
+  this.members = new HashMapImplementation();
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
-  this.constructors = new HashMapImplementation();
-  this.members = new HashMapImplementation();
-  this.factories = new FactoryMap();
-  // Initializers done
   Type.call(this, name);
 }
 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() {
@@ skipping 141 matching lines @@
 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.isUsed = false;
+  this.directSubtypes = new HashSetImplementation();
+  this.isNative = false;
   this.library = library;
   this.isClass = isClass;
-  this.directSubtypes = new HashSetImplementation();
   this.constructors = new HashMapImplementation();
+  this.factories = new FactoryMap();
   this.members = new HashMapImplementation();
-  this.factories = new FactoryMap();
-  // Initializers done
   Type.call(this, name);
   this.setDefinition(definition);
 }
 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() {
@@ skipping 74 matching lines @@
   if (!this.library.get$isCore()) return null;
   if (this.get$isBool()) return "boolean";
   else if (this.get$isNum()) return "number";
   else if (this.get$isString()) return "string";
   else if (this.get$isFunction()) return "function";
   else return null;
 }
 DefinedType.prototype.get$isNum = function() {
   return this.library != null && this.library.get$isCore() && (this.name == "num" || this.name == "int" || this.name == "double");
 }
-DefinedType.prototype.get$isInt = function() {
-  return $eq(this, $globals.world.intType);
-}
-DefinedType.prototype.get$isDouble = function() {
-  return $eq(this, $globals.world.doubleType);
-}
 DefinedType.prototype.getCallMethod = function() {
   return this.members.$index(":call");
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
   this._checkExtends();
@@ skipping 262 matching lines @@
       return this.defaultType.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if (ret != null) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._checkDefaultTypeParams = function() {
   function toList(list) {
-    return (list != null ? list : const$127);
+    return (list != null ? list : const$0008);
   }
   var typeDef = this.definition;
   if (typeDef.defaultType.oldFactory) {
     return;
   }
   var interfaceParams = toList(this.typeParameters);
   var defaultParams = toList(typeDef.defaultType.typeParameters);
   var classParams = toList(this.defaultType.typeParameters);
   if ($ne(interfaceParams.get$length(), defaultParams.get$length()) || $ne(defaultParams.get$length(), classParams.get$length())) {
     $globals.world.error("\"default\" must have the same number of type parameters as the class and interface do", this.get$span(), typeDef.defaultType.span, this.defaultType.get$span());
@@ skipping 89 matching lines @@
 DefinedType.prototype.getConstructor$1 = DefinedType.prototype.getConstructor;
 DefinedType.prototype.getFactory$2 = DefinedType.prototype.getFactory;
 DefinedType.prototype.getMember$1 = DefinedType.prototype.getMember;
 DefinedType.prototype.getOrMakeConcreteType$1 = DefinedType.prototype.getOrMakeConcreteType;
 DefinedType.prototype.markUsed$0 = DefinedType.prototype.markUsed;
 DefinedType.prototype.resolve$0 = DefinedType.prototype.resolve;
 DefinedType.prototype.resolveTypeParams$1 = DefinedType.prototype.resolveTypeParams;
 DefinedType.prototype.setDefinition$1 = DefinedType.prototype.setDefinition;
 // ********** Code for NativeType **************
 function NativeType(name) {
-  this.isConstructorHidden = false
-  this.isJsGlobalObject = false
-  this.isSingleton = false
+  this.isConstructorHidden = false;
+  this.isSingleton = false;
+  this.isJsGlobalObject = false;
   this.name = name;
-  // Initializers done
   while (true) {
     if (this.name.startsWith("@")) {
       this.name = this.name.substring((1));
       this.isJsGlobalObject = true;
     }
     else if (this.name.startsWith("*")) {
       this.name = this.name.substring((1));
       this.isConstructorHidden = true;
     }
     else {
       break;
     }
   }
   if (this.name.startsWith("=")) {
     this.name = this.name.substring((1));
     this.isSingleton = true;
   }
 }
 NativeType.prototype.get$name = function() { return this.name; };
 NativeType.prototype.set$name = function(value) { return this.name = value; };
 // ********** Code for FixedCollection **************
 function FixedCollection(value, length) {
+  this.length = length;
   this.value = value;
-  this.length = length;
-  // Initializers done
 }
 FixedCollection.prototype.get$value = function() { return this.value; };
 FixedCollection.prototype.get$length = function() { return this.length; };
 FixedCollection.prototype.iterator = function() {
   return new FixedIterator_E(this.value, this.length);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
@@ skipping 20 matching lines @@
 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
 }
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
-  this._index = (0)
+  this.length = length;
+  this._index = (0);
   this.value = value;
-  this.length = length;
-  // Initializers done
 }
 FixedIterator.prototype.get$value = function() { return this.value; };
 FixedIterator.prototype.get$length = function() { return this.length; };
 FixedIterator.prototype.hasNext = function() {
   return this._index < this.length;
 }
 FixedIterator.prototype.next = function() {
   this._index++;
   return this.value;
 }
 FixedIterator.prototype.hasNext$0 = FixedIterator.prototype.hasNext;
 FixedIterator.prototype.next$0 = FixedIterator.prototype.next;
 // ********** Code for FixedIterator_E **************
 $inherits(FixedIterator_E, FixedIterator);
 function FixedIterator_E(value, length) {
-  this._index = (0)
+  this._index = (0);
   this.value = value;
   this.length = length;
-  // Initializers done
 }
 // ********** Code for Value **************
 function Value(_type, code, span, needsTemp) {
-  this.isSuper = false
-  this.isType = false
-  this.isFinal = false
-  this.allowDynamic = true
+  this.isFinal = false;
+  this.isType = false;
+  this.allowDynamic = true;
+  this.isSuper = false;
   this._type = _type;
-  this.code = code;
   this.span = span;
   this.needsTemp = needsTemp;
-  // Initializers done
+  this.code = code;
   if (this._type == null) $globals.world.internalError("type passed as null", this.span);
 }
 Value.type$ctor = function(_type, span) {
-  this.isSuper = false
-  this.isType = false
-  this.isFinal = false
-  this.allowDynamic = true
+  this.isFinal = false;
+  this.isType = true;
+  this.allowDynamic = true;
+  this.isSuper = false;
   this._type = _type;
   this.span = span;
+  this.needsTemp = false;
   this.code = null;
-  this.needsTemp = false;
-  this.isType = true;
-  // Initializers done
   if (this._type == null) $globals.world.internalError("type passed as null", this.span);
 }
 Value.type$ctor.prototype = Value.prototype;
 Value.prototype.get$code = function() { return this.code; };
 Value.prototype.set$code = function(value) { return this.code = value; };
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.set$span = function(value) { return this.span = value; };
 Value.prototype.get$isSuper = function() { return this.isSuper; };
 Value.prototype.set$isSuper = function(value) { return this.isSuper = value; };
 Value.prototype.get$isType = function() { return this.isType; };
@@ skipping 11 matching lines @@
   if (!$globals.options.forceDynamic || !this.allowDynamic || this.isType || this.isSuper || this.get$isConst()) {
     return this._type;
   }
   else {
     return $globals.world.varType;
   }
 }
 Value.prototype.get$isConst = function() {
   return false;
 }
-Value.prototype.get$constValue = function() {
-  return null;
+Value.prototype.validateInitialized = function(span) {
+
 }
 Value.prototype.get_ = function(context, name, node) {
   var member = this._resolveMember(context, name, node, false);
   if (member != null) {
     return member._get$3(context, node, this);
   }
   else {
     return this.invokeNoSuchMethod(context, ("get:" + name), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
   var member = this._resolveMember(context, name, node, isDynamic);
   if (member != null) {
     return member._set$5(context, node, this, value, isDynamic);
   }
   else {
     return this.invokeNoSuchMethod(context, ("set:" + name), node, new Arguments(null, [value]));
   }
 }
+Value.prototype.unop = function(kind, context, node) {
+  switch (kind) {
+    case (19):
+
+      var newVal = this.convertTo(context, $globals.world.nonNullBool, false);
+      return new Value(newVal.get$type(), ("!" + newVal.get$code()), node.get$span(), true);
+
+    case (42):
+
+      $globals.world.error("no unary add operator in dart", node.get$span());
+      break;
+
+    case (43):
+
+      return this.invoke(context, ":negate", node, Arguments.get$EMPTY(), false);
+
+    case (18):
+
+      return this.invoke(context, ":bit_not", node, Arguments.get$EMPTY(), false);
+
+  }
+  $globals.world.internalError(("unimplemented: " + node.get$op()), node.get$span());
+}
 Value.prototype.binop = function(kind, other, context, node) {
   switch (kind) {
     case (35):
     case (34):
 
       var code = ("" + this.get$code() + " " + node.get$op() + " " + other.get$code());
       return new Value($globals.world.nonNullBool, code, node.get$span(), true);
 
     case (50):
 
@@ skipping 282 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);
 };
+Value.prototype.unop$3 = Value.prototype.unop;
 // ********** Code for EvaluatedValue **************
 $inherits(EvaluatedValue, Value);
 function EvaluatedValue(isConst, type, span) {
   this.isConst = isConst;
-  // Initializers done
   Value.call(this, type, "@@@", span, false);
 }
 EvaluatedValue.prototype.get$isConst = function() { return this.isConst; };
 EvaluatedValue.prototype.set$isConst = function(value) { return this.isConst = value; };
 EvaluatedValue.prototype.get$code = function() {
   return "@@@";
 }
-EvaluatedValue.prototype.get$constValue = function() {
-  return this;
-}
 EvaluatedValue.prototype.hashCode = function() {
   return this.get$code().hashCode();
 }
 EvaluatedValue.prototype.$eq = function(other) {
   return (other instanceof EvaluatedValue) && $eq(other.get$type(), this.get$type()) && $eq(other.get$code(), this.get$code());
 }
 EvaluatedValue.prototype.hashCode$0 = EvaluatedValue.prototype.hashCode;
 // ********** Code for NullValue **************
 $inherits(NullValue, EvaluatedValue);
 function NullValue(isConst, span) {
-  // Initializers done
   EvaluatedValue.call(this, isConst, $globals.world.varType, span);
 }
 NullValue.prototype.get$actualValue = function() {
   return null;
 }
 NullValue.prototype.get$code = function() {
   return "null";
 }
 NullValue.prototype.binop = function(kind, other, context, node) {
-  if (!(other instanceof ListValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  if (!(other instanceof NullValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  var c = this.isConst && other.get$isConst();
+  var s = node.get$span();
   switch (kind) {
     case (50):
+    case (48):
 
-      return new BoolValue($eq(this.get$type(), other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(true, c, s);
 
     case (51):
+    case (49):
 
-      return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(false, c, s);
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 NullValue.prototype.binop$4 = NullValue.prototype.binop;
 // ********** Code for BoolValue **************
 $inherits(BoolValue, EvaluatedValue);
 function BoolValue(actualValue, isConst, span) {
   this.actualValue = actualValue;
-  // Initializers done
   EvaluatedValue.call(this, isConst, $globals.world.nonNullBool, span);
 }
 BoolValue.prototype.get$actualValue = function() { return this.actualValue; };
 BoolValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 BoolValue.prototype.get$code = function() {
   return this.actualValue ? "true" : "false";
 }
+BoolValue.prototype.unop = function(kind, context, node) {
+  switch (kind) {
+    case (19):
+
+      return new BoolValue(!this.actualValue, this.isConst, node.get$span());
+
+  }
+  return Value.prototype.unop.call(this, kind, context, node);
+}
 BoolValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof BoolValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  var c = this.isConst && other.get$isConst();
+  var s = node.get$span();
+  var x = this.actualValue, y = other.get$actualValue();
   switch (kind) {
+    case (50):
+    case (48):
+
+      return new BoolValue($eq(x, y), c, s);
+
+    case (51):
+    case (49):
+
+      return new BoolValue($ne(x, y), c, s);
+
     case (35):
 
-      return new BoolValue(this.actualValue && other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(x && y, c, s);
 
     case (34):
 
-      return new BoolValue(this.actualValue || other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
-
-    case (50):
-
-      return new BoolValue($eq(this.actualValue, other.get$actualValue()), this.isConst && other.get$isConst(), node.get$span());
-
-    case (51):
-
-      return new BoolValue($ne(this.actualValue, other.get$actualValue()), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(x || y, c, s);
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 BoolValue.prototype.binop$4 = BoolValue.prototype.binop;
+BoolValue.prototype.unop$3 = BoolValue.prototype.unop;
 // ********** Code for IntValue **************
 $inherits(IntValue, EvaluatedValue);
 function IntValue(actualValue, isConst, span) {
   this.actualValue = actualValue;
-  // Initializers done
   EvaluatedValue.call(this, isConst, $globals.world.intType, span);
 }
 IntValue.prototype.get$actualValue = function() { return this.actualValue; };
 IntValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 IntValue.prototype.get$code = function() {
   return ("(" + this.actualValue + ")");
 }
+IntValue.prototype.unop = function(kind, context, node) {
+  switch (kind) {
+    case (42):
+
+      return new IntValue(this.actualValue, this.isConst, this.span);
+
+    case (43):
+
+      return new IntValue(-this.actualValue, this.isConst, this.span);
+
+    case (18):
+
+      return new IntValue(~this.actualValue, this.isConst, this.span);
+
+  }
+  return Value.prototype.unop.call(this, kind, context, node);
+}
 IntValue.prototype.binop = function(kind, other, context, node) {
-  if (!(other instanceof IntValue)) return Value.prototype.binop.call(this, kind, other, context, node);
-  switch (kind) {
-    case (50):
+  var c = this.isConst && other.get$isConst();
+  var s = node.get$span();
+  if ((other instanceof IntValue)) {
+    var x = this.actualValue;
+    var y = other.get$actualValue();
+    switch (kind) {
+      case (50):
+      case (48):
 
-      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+        return new BoolValue(x == y, c, s);
 
-    case (51):
+      case (51):
+      case (49):
 
-      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+        return new BoolValue(x != y, c, s);
 
+      case (36):
+
+        return new IntValue(x | y, c, s);
+
+      case (37):
+
+        return new IntValue(x ^ y, c, s);
+
+      case (38):
+
+        return new IntValue(x & y, c, s);
+
+      case (39):
+
+        return new IntValue(x << y, c, s);
+
+      case (40):
+
+        return new IntValue(x >> y, c, s);
+
+      case (41):
+
+        return new IntValue(x >>> y, c, s);
+
+      case (42):
+
+        return new IntValue(x + y, c, s);
+
+      case (43):
+
+        return new IntValue(x - y, c, s);
+
+      case (44):
+
+        return new IntValue(x * y, c, s);
+
+      case (45):
+
+        return new DoubleValue(x / y, c, s);
+
+      case (46):
+
+        return new IntValue($truncdiv(x, y), c, s);
+
+      case (47):
+
+        return new IntValue($mod(x, y), c, s);
+
+      case (52):
+
+        return new BoolValue(x < y, c, s);
+
+      case (53):
+
+        return new BoolValue(x > y, c, s);
+
+      case (54):
+
+        return new BoolValue(x <= y, c, s);
+
+      case (55):
+
+        return new BoolValue(x >= y, c, s);
+
+    }
+  }
+  else if ((other instanceof DoubleValue)) {
+    var x = this.actualValue;
+    var y = other.get$actualValue();
+    switch (kind) {
+      case (50):
+      case (48):
+
+        return new BoolValue(x == y, c, s);
+
+      case (51):
+      case (49):
+
+        return new BoolValue(x != y, c, s);
+
+      case (42):
+
+        return new DoubleValue(x + y, c, s);
+
+      case (43):
+
+        return new DoubleValue(x - y, c, s);
+
+      case (44):
+
+        return new DoubleValue(x * y, c, s);
+
+      case (45):
+
+        return new DoubleValue(x / y, c, s);
+
+      case (46):
+
+        return new DoubleValue($truncdiv(x, y), c, s);
+
+      case (47):
+
+        return new DoubleValue($mod(x, y), c, s);
+
+      case (52):
+
+        return new BoolValue(x < y, c, s);
+
+      case (53):
+
+        return new BoolValue(x > y, c, s);
+
+      case (54):
+
+        return new BoolValue(x <= y, c, s);
+
+      case (55):
+
+        return new BoolValue(x >= y, c, s);
+
+    }
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 IntValue.prototype.binop$4 = IntValue.prototype.binop;
+IntValue.prototype.unop$3 = IntValue.prototype.unop;
 // ********** Code for DoubleValue **************
 $inherits(DoubleValue, EvaluatedValue);
 function DoubleValue(actualValue, isConst, span) {
   this.actualValue = actualValue;
-  // Initializers done
   EvaluatedValue.call(this, isConst, $globals.world.doubleType, span);
 }
 DoubleValue.prototype.get$actualValue = function() { return this.actualValue; };
 DoubleValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 DoubleValue.prototype.get$code = function() {
   return ("(" + this.actualValue + ")");
 }
+DoubleValue.prototype.unop = function(kind, context, node) {
+  switch (kind) {
+    case (42):
+
+      return new DoubleValue(this.actualValue, this.isConst, this.span);
+
+    case (43):
+
+      return new DoubleValue(-this.actualValue, this.isConst, this.span);
+
+  }
+  return Value.prototype.unop.call(this, kind, context, node);
+}
 DoubleValue.prototype.binop = function(kind, other, context, node) {
-  if (!(other instanceof DoubleValue)) return Value.prototype.binop.call(this, kind, other, context, node);
-  switch (kind) {
-    case (50):
+  var c = this.isConst && other.get$isConst();
+  var s = node.get$span();
+  if ((other instanceof DoubleValue)) {
+    var x = this.actualValue;
+    var y = other.get$actualValue();
+    switch (kind) {
+      case (50):
+      case (48):
 
-      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+        return new BoolValue(x == y, c, s);
 
-    case (51):
+      case (51):
+      case (49):
 
-      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+        return new BoolValue(x != y, c, s);
 
+      case (42):
+
+        return new DoubleValue(x + y, c, s);
+
+      case (43):
+
+        return new DoubleValue(x - y, c, s);
+
+      case (44):
+
+        return new DoubleValue(x * y, c, s);
+
+      case (45):
+
+        return new DoubleValue(x / y, c, s);
+
+      case (46):
+
+        return new DoubleValue($truncdiv(x, y), c, s);
+
+      case (47):
+
+        return new DoubleValue($mod(x, y), c, s);
+
+      case (52):
+
+        return new BoolValue(x < y, c, s);
+
+      case (53):
+
+        return new BoolValue(x > y, c, s);
+
+      case (54):
+
+        return new BoolValue(x <= y, c, s);
+
+      case (55):
+
+        return new BoolValue(x >= y, c, s);
+
+    }
+  }
+  else if ((other instanceof IntValue)) {
+    var x = this.actualValue;
+    var y = other.get$actualValue();
+    switch (kind) {
+      case (50):
+      case (48):
+
+        return new BoolValue(x == y, c, s);
+
+      case (51):
+      case (49):
+
+        return new BoolValue(x != y, c, s);
+
+      case (42):
+
+        return new DoubleValue(x + y, c, s);
+
+      case (43):
+
+        return new DoubleValue(x - y, c, s);
+
+      case (44):
+
+        return new DoubleValue(x * y, c, s);
+
+      case (45):
+
+        return new DoubleValue(x / y, c, s);
+
+      case (46):
+
+        return new DoubleValue($truncdiv(x, y), c, s);
+
+      case (47):
+
+        return new DoubleValue($mod(x, y), c, s);
+
+      case (52):
+
+        return new BoolValue(x < y, c, s);
+
+      case (53):
+
+        return new BoolValue(x > y, c, s);
+
+      case (54):
+
+        return new BoolValue(x <= y, c, s);
+
+      case (55):
+
+        return new BoolValue(x >= y, c, s);
+
+    }
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 DoubleValue.prototype.binop$4 = DoubleValue.prototype.binop;
+DoubleValue.prototype.unop$3 = DoubleValue.prototype.unop;
 // ********** Code for StringValue **************
 $inherits(StringValue, EvaluatedValue);
 function StringValue(actualValue, isConst, span) {
   this.actualValue = actualValue;
-  // Initializers done
   EvaluatedValue.call(this, isConst, $globals.world.stringType, span);
 }
 StringValue.prototype.get$actualValue = function() { return this.actualValue; };
 StringValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 StringValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof StringValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  var c = this.isConst && other.get$isConst();
+  var s = node.get$span();
+  var x = this.actualValue, y = other.get$actualValue();
   switch (kind) {
     case (50):
+    case (48):
 
-      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(x == y, c, s);
 
     case (51):
+    case (49):
 
-      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+      return new BoolValue(x != y, c, s);
+
+    case (42):
+
+      return new StringValue(x + y, c, s);
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 StringValue.prototype.get$code = function() {
   var buf = new StringBufferImpl("");
   buf.add("\"");
   for (var i = (0);
    i < this.actualValue.length; i++) {
     var ch = this.actualValue.charCodeAt(i);
@@ skipping 67 matching lines @@
     }
   }
   buf.add("\"");
   return buf.toString();
 }
 StringValue.prototype.binop$4 = StringValue.prototype.binop;
 // ********** Code for ListValue **************
 $inherits(ListValue, EvaluatedValue);
 function ListValue(values, isConst, type, span) {
   this.values = values;
-  // Initializers done
   EvaluatedValue.call(this, isConst, type, span);
 }
 ListValue.prototype.get$code = function() {
   var buf = new StringBufferImpl("");
   buf.add("[");
   for (var i = (0);
    i < this.values.get$length(); i = i + (1)) {
     if (i > (0)) buf.add(", ");
     buf.add(this.values.$index(i).get$code());
   }
@@ skipping 21 matching lines @@
 }
 ListValue.prototype.getGlobalValue = function() {
   return $globals.world.gen.globalForConst(this, this.values);
 }
 ListValue.prototype.binop$4 = ListValue.prototype.binop;
 ListValue.prototype.getGlobalValue$0 = ListValue.prototype.getGlobalValue;
 // ********** Code for MapValue **************
 $inherits(MapValue, EvaluatedValue);
 function MapValue(values, isConst, type, span) {
   this.values = values;
-  // Initializers done
   EvaluatedValue.call(this, isConst, type, span);
 }
 MapValue.prototype.get$code = function() {
   var items = new ListValue(this.values, false, $globals.world.listType, this.span);
   var tp = $globals.world.corelib.topType;
   var f = this.isConst ? tp.getMember$1("_constMap") : tp.getMember$1("_map");
   var value = f.invoke(null, null, new Value.type$ctor(tp, null), new Arguments(null, [items]), false);
   return value.get$code();
 }
 MapValue.prototype.getGlobalValue = function() {
@@ skipping 10 matching lines @@
 
       return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 MapValue.prototype.binop$4 = MapValue.prototype.binop;
 MapValue.prototype.getGlobalValue$0 = MapValue.prototype.getGlobalValue;
 // ********** Code for ObjectValue **************
 $inherits(ObjectValue, EvaluatedValue);
-function ObjectValue(fields, isConst, type, _code, span) {
-  this.fields = fields;
-  this._code = _code;
-  // Initializers done
+function ObjectValue(isConst, type, span) {
+  this.seenNativeInitializer = false;
+  this.fields = new HashMapImplementation();
   EvaluatedValue.call(this, isConst, type, span);
 }
 ObjectValue.prototype.get$fields = function() { return this.fields; };
 ObjectValue.prototype.set$fields = function(value) { return this.fields = value; };
+ObjectValue.prototype.get$seenNativeInitializer = function() { return this.seenNativeInitializer; };
+ObjectValue.prototype.set$seenNativeInitializer = function(value) { return this.seenNativeInitializer = value; };
 ObjectValue.prototype.get$code = function() {
+  if (this._code == null) this.validateInitialized(null);
   return this._code;
 }
+ObjectValue.prototype.initFields = function() {
+  var allMembers = $globals.world.gen._orderValues(this.get$type().getAllMembers());
+  for (var $$i = allMembers.iterator$0(); $$i.hasNext$0(); ) {
+    var f = $$i.next$0();
+    if (f.get$isField() && !f.get$isStatic() && f.get$declaringType().get$isClass()) {
+      this.fields.$setindex(f, f.computeValue$0());
+    }
+  }
+}
+ObjectValue.prototype.setField = function(field, value, duringInit) {
+  var currentValue = this.fields.$index(field);
+  if (this.isConst && !value.get$isConst()) {
+    $globals.world.error("used of non-const value in const intializer", value.span);
+  }
+  if (currentValue == null) {
+    this.fields.$setindex(field, value);
+    if (field.get$isFinal() && !duringInit) {
+      $globals.world.error("can not initialize final fields outside of initializer", value.span);
+    }
+  }
+  else {
+    if (field.get$isFinal() && field.computeValue() == null) {
+      $globals.world.error("reassignment of field not allowed", value.span, field.get$span());
+    }
+    else {
+      this.fields.$setindex(field, value);
+    }
+  }
+}
+ObjectValue.prototype.validateInitialized = function(span) {
+  var buf = new StringBufferImpl("");
+  buf.add$1("Object.create(");
+  buf.add$1(("" + this.get$type().get$jsname() + ".prototype, "));
+  buf.add$1("{");
+  var $$list = this.fields.getKeys();
+  for (var $$i = this.fields.getKeys().iterator$0(); $$i.hasNext$0(); ) {
+    var field = $$i.next$0();
+    buf.add$1(field.get$name());
+    buf.add$1(": ");
+    buf.add$1("{\"value\": ");
+    if (this.fields.$index(field) == null) {
+      $globals.world.error(("Required field \"" + field.get$name() + "\" was not initialized"), span, field.get$span());
+      buf.add$1("null");
+    }
+    else {
+      buf.add$1(this.fields.$index(field).get$code());
+    }
+    buf.add$1(", writeable: false}, ");
+  }
+  buf.add$1("})");
+  this._code = buf.toString$0();
+}
 ObjectValue.prototype.binop = function(kind, other, context, node) {
   if (!(other instanceof ObjectValue)) return Value.prototype.binop.call(this, kind, other, context, node);
   switch (kind) {
     case (50):
+    case (48):
 
       return new BoolValue($eq(this.get$type(), other.get$type()) && this.get$code() == other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
     case (51):
+    case (49):
 
       return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
 
   }
   return Value.prototype.binop.call(this, kind, other, context, node);
 }
 ObjectValue.prototype.binop$4 = ObjectValue.prototype.binop;
+ObjectValue.prototype.initFields$0 = ObjectValue.prototype.initFields;
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
 function GlobalValue(type, code, isConst, field, name, exp, span, _dependencies) {
+  this.exp = exp;
   this.field = field;
   this.name = name;
-  this.exp = exp;
   this.dependencies = [];
-  // Initializers done
+  this.isConst = isConst;
   Value.call(this, type, code, span, !isConst);
   for (var $$i = 0;$$i < _dependencies.get$length(); $$i++) {
     var dep = _dependencies.$index($$i);
     if ((dep instanceof GlobalValue)) {
       this.dependencies.add(dep);
       this.dependencies.addAll(dep.get$dependencies());
     }
   }
 }
 GlobalValue.prototype.get$field = function() { return this.field; };
 GlobalValue.prototype.set$field = function(value) { return this.field = value; };
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
 GlobalValue.prototype.get$exp = function() { return this.exp; };
 GlobalValue.prototype.set$exp = function(value) { return this.exp = value; };
-GlobalValue.prototype.get$isConst = function() {
-  return this.exp.get$isConst() && (this.field == null || this.field.isFinal);
-}
+GlobalValue.prototype.get$isConst = function() { return this.isConst; };
+GlobalValue.prototype.set$isConst = function(value) { return this.isConst = value; };
 GlobalValue.prototype.get$actualValue = function() {
   return this.exp.get$dynamic().get$actualValue();
 }
-GlobalValue.prototype.get$constValue = function() {
-  return this.get$isConst() ? this.exp.get$constValue() : null;
-}
 GlobalValue.prototype.get$dependencies = function() { return this.dependencies; };
 GlobalValue.prototype.set$dependencies = function(value) { return this.dependencies = value; };
 GlobalValue.prototype.compareTo = function(other) {
   if ($eq(other, this)) {
     return (0);
   }
   else if (this.dependencies.indexOf(other) >= (0)) {
     return (1);
   }
   else if (other.dependencies.indexOf(this) >= (0)) {
@@ skipping 16 matching lines @@
   }
   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();
 }
 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();
@@ skipping 15 matching lines @@
   if (member != null) {
     return member;
   }
   this._ensureCode();
   return null;
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
   this._lang_message = _message;
   this._location = _location;
-  // Initializers done
 }
 CompilerException.prototype.toString = function() {
   if (this._location != null) {
     return ("CompilerException: " + this._location.toMessageString(this._lang_message));
   }
   else {
     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
   this.files = files;
-  this.libraries = new HashMapImplementation();
-  this._todo = [];
   this._members = new HashMapImplementation();
   this._topNames = new HashMapImplementation();
+  this.warnings = (0);
+  this.seenFatal = false;
+  this.libraries = new HashMapImplementation();
+  this.dartBytesRead = (0);
+  this._todo = [];
+  this.jsBytesWritten = (0);
+  this.errors = (0);
   this.reader = new LibraryReader();
-  // Initializers done
 }
 World.prototype.get$functionType = function() { return this.functionType; };
 World.prototype.set$functionType = function(value) { return this.functionType = value; };
 World.prototype.init = function() {
   this.corelib = new Library(this.readFile("dart:core"));
   this.libraries.$setindex("dart:core", this.corelib);
   this._todo.add(this.corelib);
   this.coreimpl = this.getOrAddLibrary("dart:coreimpl");
   this.voidType = this.corelib.addType("void", null, false);
   this.dynamicType = this.corelib.addType("Dynamic", null, false);
@@ skipping 330 matching lines @@
 World.prototype.withTiming = function(name, f) {
   var sw = new StopwatchImplementation();
   sw.start();
   var result = f();
   sw.stop();
   this.info(("" + name + " in " + sw.elapsedInMs() + "msec"));
   return result;
 }
 // ********** Code for FrogOptions **************
 function FrogOptions(homedir, args, files) {
-  this.config = "dev"
-  this.enableLeg = false
-  this.legOnly = false
-  this.enableAsserts = false
-  this.enableTypeChecks = false
-  this.warningsAsErrors = false
-  this.verifyImplements = false
-  this.compileAll = false
-  this.forceDynamic = false
-  this.dietParse = false
-  this.compileOnly = false
-  this.throwOnErrors = false
-  this.throwOnWarnings = false
-  this.throwOnFatal = false
-  this.showInfo = false
-  this.showWarnings = true
-  this.useColors = true
-  // Initializers done
+  this.legOnly = false;
+  this.throwOnFatal = false;
+  this.config = "dev";
+  this.throwOnWarnings = false;
+  this.verifyImplements = false;
+  this.warningsAsErrors = false;
+  this.enableLeg = false;
+  this.enableAsserts = false;
+  this.enableTypeChecks = false;
+  this.forceDynamic = false;
+  this.showInfo = false;
+  this.dietParse = false;
+  this.useColors = true;
+  this.compileOnly = false;
+  this.showWarnings = true;
+  this.compileAll = false;
+  this.throwOnErrors = false;
   if ($eq(this.config, "dev")) {
     this.libDir = joinPaths(homedir, "/lib");
   }
   else if ($eq(this.config, "sdk")) {
     this.libDir = joinPaths(homedir, "/../lib");
   }
   else {
     $globals.world.error(("Invalid configuration " + this.config));
     $throw("Invalid configuration");
   }
@@ skipping 114 matching lines @@
     if (files.fileExists(temp)) {
       this.libDir = temp;
     }
     else {
       this.libDir = "lib";
     }
   }
 }
 // ********** Code for LibraryReader **************
 function LibraryReader() {
-  // Initializers done
   if ($eq($globals.options.config, "dev")) {
     this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "corelib.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "corelib_impl.dart"), "dart:html", joinPaths($globals.options.libDir, "../../client/html/release/html.dart"), "dart:htmlimpl", joinPaths($globals.options.libDir, "../../client/html/release/htmlimpl.dart"), "dart:dom", joinPaths($globals.options.libDir, "../../client/dom/frog/dom_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "json_frog.dart")]);
   }
   else if ($eq($globals.options.config, "sdk")) {
     this._specialLibs = _map(["dart:core", joinPaths($globals.options.libDir, "core/core_frog.dart"), "dart:coreimpl", joinPaths($globals.options.libDir, "coreimpl/coreimpl_frog.dart"), "dart:html", joinPaths($globals.options.libDir, "html/html.dart"), "dart:htmlimpl", joinPaths($globals.options.libDir, "htmlimpl/htmlimpl.dart"), "dart:dom", joinPaths($globals.options.libDir, "dom/frog/dom_frog.dart"), "dart:json", joinPaths($globals.options.libDir, "json/json_frog.dart")]);
   }
   else {
     $globals.world.error(("Invalid configuration " + $globals.options.config));
   }
 }
 LibraryReader.prototype.readFile = function(fullname) {
   var filename = this._specialLibs.$index(fullname);
   if (filename == null) {
     filename = fullname;
   }
   if ($globals.world.files.fileExists(filename)) {
     return new SourceFile(filename, $globals.world.files.readAll(filename));
   }
   else {
     $globals.world.error(("File not found: " + filename));
     return new SourceFile(filename, "");
   }
 }
 // ********** Code for VarMember **************
 function VarMember(name) {
-  this.isGenerated = false
+  this.isGenerated = false;
   this.name = name;
-  // Initializers done
 }
 VarMember.prototype.get$name = function() { return this.name; };
 VarMember.prototype.get$isGenerated = function() { return this.isGenerated; };
 VarMember.prototype.set$isGenerated = function(value) { return this.isGenerated = value; };
 VarMember.prototype.get$returnType = function() {
   return $globals.world.varType;
 }
 VarMember.prototype.invoke = function(context, node, target, args) {
   return new Value(this.get$returnType(), ("" + target.get$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.functionImplType.markUsed();
   $globals.world.gen.genMethod($globals.world.functionImplType.getMember("_genStub"));
 }
 VarFunctionStub.prototype.invoke = function(context, node, target, args) {
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarFunctionStub.prototype.generate = function(code) {
   this.isGenerated = true;
   if (this.args.get$hasNames()) {
@@ skipping 22 matching lines @@
   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;
 VarFunctionStub.prototype.invoke$4 = VarFunctionStub.prototype.invoke;
 // ********** Code for VarMethodStub **************
 $inherits(VarMethodStub, VarMember);
 function VarMethodStub(name, member, args, body) {
+  this.body = body;
   this.member = member;
   this.args = args;
-  this.body = body;
-  // Initializers done
   VarMember.call(this, name);
 }
 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() {
@@ skipping 45 matching lines @@
     return method.namesInHomePositions(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.args = callArgs.toCallStubArgs();
+  this.invoked = false;
   this.baseName = baseName;
   this.members = members;
   this.returnType = returnType;
-  this.args = callArgs.toCallStubArgs();
-  // Initializers done
   VarMember.call(this, name);
 }
 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;
@@ skipping 145 matching lines @@
 // 1 dynamic types.
 // 1 types
 // 0 !leaf
 //  ********** Globals **************
 function $static_init(){
   $globals._GREEN_COLOR = "\x1b[32m";
   $globals._MAGENTA_COLOR = "\x1b[35m";
   $globals._NO_COLOR = "\x1b[0m";
   $globals._RED_COLOR = "\x1b[31m";
 }
-var const$1 = new EmptyQueueException();
-var const$126 = new IllegalAccessException();
-var const$127 = ImmutableList.ImmutableList$from$factory([]);
-var const$2 = new _DeletedKeySentinel();
-var const$7 = new NoMoreElementsException();
+var const$0000 = Object.create(EmptyQueueException.prototype, {});
+var const$0001 = Object.create(_DeletedKeySentinel.prototype, {});
+var const$0005 = Object.create(NoMoreElementsException.prototype, {});
+var const$0007 = Object.create(IllegalAccessException.prototype, {});
+var const$0008 = ImmutableList.ImmutableList$from$factory([]);
 var $globals = {};
 $static_init();
 main();