Fixes 2 tests and a crash

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 97 matching lines @@
 };
 Object.prototype.addDirectSubtype$1 = function($0) {
   return this.noSuchMethod("addDirectSubtype", [$0]);
 };
 Object.prototype.addMethod$2 = function($0, $1) {
   return this.noSuchMethod("addMethod", [$0, $1]);
 };
 Object.prototype.addSource$1 = function($0) {
   return this.noSuchMethod("addSource", [$0]);
 };
+Object.prototype.binop$4 = function($0, $1, $2, $3) {
+  return this.noSuchMethod("binop", [$0, $1, $2, $3]);
+};
 Object.prototype.block$0 = function() {
   return this.noSuchMethod("block", []);
 };
 Object.prototype.canInvoke$2 = function($0, $1) {
   return this.noSuchMethod("canInvoke", [$0, $1]);
 };
 Object.prototype.checkFirstClass$1 = function($0) {
   return this.noSuchMethod("checkFirstClass", [$0]);
 };
 Object.prototype.compareTo$1 = function($0) {
@@ skipping 46 matching lines @@
 };
 Object.prototype.getColumn$2 = function($0, $1) {
   return this.noSuchMethod("getColumn", [$0, $1]);
 };
 Object.prototype.getConstructor$1 = function($0) {
   return this.noSuchMethod("getConstructor", [$0]);
 };
 Object.prototype.getFactory$2 = function($0, $1) {
   return this.noSuchMethod("getFactory", [$0, $1]);
 };
+Object.prototype.getGlobalValue$0 = function() {
+  return this.noSuchMethod("getGlobalValue", []);
+};
 Object.prototype.getKeys$0 = function() {
   return this.noSuchMethod("getKeys", []);
 };
 Object.prototype.getLine$1 = function($0) {
   return this.noSuchMethod("getLine", [$0]);
 };
 Object.prototype.getMember$1 = function($0) {
   return this.noSuchMethod("getMember", [$0]);
 };
 Object.prototype.getOrMakeConcreteType$1 = function($0) {
@@ skipping 97 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.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;
+  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;
+  for (var i = (0);
    i < this._arguments.get$length(); i++) {
-    if (i > 0) {
+    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() {
@@ skipping 116 matching lines @@
   if (typeof console == 'object') {
     if (obj) obj = obj.toString();
     console.log(obj);
   } else {
     write(obj);
     write('\n');
   }
 }
 function _map(itemsAndKeys) {
   var ret = new LinkedHashMapImplementation();
-  for (var i = 0;
+  for (var i = (0);
    i < itemsAndKeys.get$length(); ) {
     ret.$setindex(itemsAndKeys.$index(i++), itemsAndKeys.$index(i++));
   }
   return ret;
 }
 function _toDartException(e) {
   function attachStack(dartEx) {
     // TODO(jmesserly): setting the stack property is not a long term solution.
     var stack = e.stack;
     // The stack contains the error message, and the stack is all that is
@@ skipping 64 matching lines @@
 ListFactory.prototype.addLast = function(value) {
   this.push(value);
 }
 ListFactory.prototype.addAll = function(collection) {
   for (var $$i = collection.iterator(); $$i.hasNext$0(); ) {
     var item = $$i.next$0();
     this.add(item);
   }
 }
 ListFactory.prototype.clear = function() {
-  this.set$length(0);
+  this.set$length((0));
 }
 ListFactory.prototype.removeLast = function() {
   return this.pop();
 }
 ListFactory.prototype.last = function() {
-  return this[this.get$length() - 1];
+  return this[this.get$length() - (1)];
 }
 ListFactory.prototype.getRange = function(start, length) {
   return this.slice(start, start + length);
 }
 ListFactory.prototype.isEmpty = function() {
-  return this.get$length() == 0;
+  return this.get$length() == (0);
 }
 ListFactory.prototype.iterator = function() {
   return new ListIterator(this);
 }
 ListFactory.prototype.add$1 = ListFactory.prototype.add;
 ListFactory.prototype.addAll$1 = ListFactory.prototype.addAll;
 ListFactory.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 ListFactory.prototype.filter$1 = function($0) {
@@ skipping 11 matching lines @@
   return this.some(to$call$1($0));
 };
 ListFactory.prototype.sort$1 = function($0) {
   return this.sort(to$call$2($0));
 };
 ListFactory_E = ListFactory;
 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;
+  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/*const NoMoreElementsException()*/);
+    $throw(const$7);
   }
   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;
+  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/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 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/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.sort = function(compare) {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.add = function(element) {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.addLast = function(element) {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.addAll = function(elements) {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.clear = function() {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 ImmutableList.prototype.removeLast = function() {
-  $throw(const$126/*const IllegalAccessException()*/);
+  $throw(const$126);
 }
 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));
 };
@@ skipping 21 matching lines @@
 }
 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;
+    return (-1);
   }
   else if (thisValue > other) {
-    return 1;
+    return (1);
   }
   else if (thisValue == other) {
-    if (thisValue == 0) {
+    if (thisValue == (0)) {
       var thisIsNegative = this.isNegative();
       var otherIsNegative = other.isNegative();
-      if ($eq(thisIsNegative, otherIsNegative)) return 0;
-      if (thisIsNegative) return -1;
-      return 1;
+      if ($eq(thisIsNegative, otherIsNegative)) return (0);
+      if (thisIsNegative) return (-1);
+      return (1);
     }
-    return 0;
+    return (0);
   }
   else if (this.isNaN()) {
     if (other.isNaN()) {
-      return 0;
+      return (0);
     }
-    return 1;
+    return (1);
   }
   else {
-    return -1;
+    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/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._keys = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._values = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  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);
   })
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
-  return $truncdiv((capacity * 3), 4);
+  return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation._firstProbe = function(hashCode, length) {
-  return hashCode & (length - 1);
+  return hashCode & (length - (1));
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - 1);
+  return (currentProbe + numberOfProbes) & (length - (1));
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode$0(), this._keys.get$length());
-  var numberOfProbes = 1;
+  var numberOfProbes = (1);
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = (-1);
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
-      if (insertionIndex < 0) return hash;
+      if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ((insertionIndex < 0) && (const$2/*HashMapImplementation._DELETED_KEY*/ === existingKey)) {
+    else if ((insertionIndex < (0)) && (const$2 == 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 numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + 1;
+  var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
-    this._grow(this._keys.get$length() * 2);
+    this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation._isPowerOfTwo = function(x) {
-  return ((x & (x - 1)) == 0);
+  return ((x & (x - (1))) == (0));
 }
 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;
+  for (var i = (0);
    i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key === const$2/*HashMapImplementation._DELETED_KEY*/) {
+    if (key == null || key == const$2) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
-  this._numberOfDeleted = 0;
+  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/*HashMapImplementation._DELETED_KEY*/)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$2)) {
     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;
+  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);
+  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) {
+  if (index >= (0)) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
-    this._keys.$setindex(index, const$2/*HashMapImplementation._DELETED_KEY*/);
+    this._keys.$setindex(index, const$2);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation.prototype.isEmpty = function() {
-  return this._numberOfEntries == 0;
+  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;
+  for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== const$2/*HashMapImplementation._DELETED_KEY*/)) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$2)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
-  var i = 0;
+  var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.getValues = function() {
   var list = new Array(this.get$length());
-  var i = 0;
+  var i = (0);
   this.forEach(function _(key, value) {
     list.$setindex(i++, value);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.containsKey = function(key) {
-  return (this._probeForLookup(key) != -1);
+  return (this._probeForLookup(key) != (-1));
 }
 HashMapImplementation.prototype.containsKey$1 = HashMapImplementation.prototype.containsKey;
 HashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 HashMapImplementation.prototype.getKeys$0 = HashMapImplementation.prototype.getKeys;
 HashMapImplementation.prototype.getValues$0 = HashMapImplementation.prototype.getValues;
 HashMapImplementation.prototype.isEmpty$0 = HashMapImplementation.prototype.isEmpty;
 // ********** Code for HashMapImplementation_E$E **************
 $inherits(HashMapImplementation_E$E, HashMapImplementation);
 function HashMapImplementation_E$E() {
   // Initializers done
-  this._numberOfEntries = 0;
-  this._numberOfDeleted = 0;
-  this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._keys = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._values = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  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);
+  return $truncdiv((capacity * (3)), (4));
 }
 HashMapImplementation_E$E._firstProbe = function(hashCode, length) {
-  return hashCode & (length - 1);
+  return hashCode & (length - (1));
 }
 HashMapImplementation_E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - 1);
+  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 numberOfProbes = (1);
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = (-1);
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
-      if (insertionIndex < 0) return hash;
+      if (insertionIndex < (0)) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ((insertionIndex < 0) && (const$2/*HashMapImplementation._DELETED_KEY*/ === existingKey)) {
+    else if ((insertionIndex < (0)) && (const$2 == 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 numberOfProbes = (1);
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return (-1);
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.get$length());
   }
 }
 HashMapImplementation_E$E.prototype._ensureCapacity = function() {
-  var newNumberOfEntries = this._numberOfEntries + 1;
+  var newNumberOfEntries = this._numberOfEntries + (1);
   if (newNumberOfEntries >= this._loadLimit) {
-    this._grow(this._keys.get$length() * 2);
+    this._grow(this._keys.get$length() * (2));
     return;
   }
   var capacity = this._keys.get$length();
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.get$length());
   }
 }
 HashMapImplementation_E$E._isPowerOfTwo = function(x) {
-  return ((x & (x - 1)) == 0);
+  return ((x & (x - (1))) == (0));
 }
 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;
+  for (var i = (0);
    i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key === const$2/*HashMapImplementation._DELETED_KEY*/) {
+    if (key == null || key == const$2) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
-  this._numberOfDeleted = 0;
+  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/*HashMapImplementation._DELETED_KEY*/)) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) == const$2)) {
     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) {
+  if (index >= (0)) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
-    this._keys.$setindex(index, const$2/*HashMapImplementation._DELETED_KEY*/);
+    this._keys.$setindex(index, const$2);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation_E$E.prototype.isEmpty = function() {
-  return this._numberOfEntries == 0;
+  return this._numberOfEntries == (0);
 }
 HashMapImplementation_E$E.prototype.forEach = function(f) {
   var length = this._keys.get$length();
-  for (var i = 0;
+  for (var i = (0);
    i < length; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== const$2/*HashMapImplementation._DELETED_KEY*/)) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) != const$2)) {
       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;
+  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);
+  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/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._keys = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
-  this._values = new Array(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  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);
+  return $truncdiv((capacity * (3)), (4));
 }
-// ********** Code for HashMapImplementation_dart_core_String$EvaluatedValue **************
-$inherits(HashMapImplementation_dart_core_String$EvaluatedValue, HashMapImplementation);
-function HashMapImplementation_dart_core_String$EvaluatedValue() {}
+// ********** 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);
@@ skipping 76 matching lines @@
 $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._nextValidIndex = -1;
+  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/*HashMapImplementation._DELETED_KEY*/) {
+  if (this._entries.$index(this._nextValidIndex) == const$2) {

[Jennifer Messerly, 2012/01/09 19:06:54]

Nice. I think this actually improves readability. However one thing we might
want to consider in the future: instead of generating names like const$num, to
generate a string with a more human readable name.

(I also want to shorten $globals)

     this._advance();
   }
   return this._nextValidIndex < this._entries.get$length();
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$7/*const NoMoreElementsException()*/);
+    $throw(const$7);
   }
   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/*HashMapImplementation._DELETED_KEY*/;
+  var deletedKey = const$2;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ((entry == null) || (entry === deletedKey))
+  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._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/*HashMapImplementation._DELETED_KEY*/;
+  var deletedKey = const$2;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ((entry == null) || (entry === deletedKey))
+  while ((entry == null) || (entry == deletedKey))
 }
 // ********** Code for _DeletedKeySentinel **************
 function _DeletedKeySentinel() {
   // Initializers done
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
@@ skipping 30 matching lines @@
 LinkedHashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
   var value = this.$index(key);
   if ((this.$index(key) == null) && !(this.containsKey(key))) {
     value = ifAbsent();
     this.$setindex(key, value);
   }
   return value;
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new Array(this.get$length());
-  var index = 0;
+  var index = (0);
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
   var list = new Array(this.get$length());
-  var index = 0;
+  var index = (0);
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
   this._list.forEach(function _(entry) {
     f(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.get$length();
 }
 LinkedHashMapImplementation.prototype.isEmpty = function() {
-  return this.get$length() == 0;
+  return this.get$length() == (0);
 }
 LinkedHashMapImplementation.prototype.containsKey$1 = LinkedHashMapImplementation.prototype.containsKey;
 LinkedHashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 LinkedHashMapImplementation.prototype.getKeys$0 = LinkedHashMapImplementation.prototype.getKeys;
 LinkedHashMapImplementation.prototype.getValues$0 = LinkedHashMapImplementation.prototype.getValues;
 LinkedHashMapImplementation.prototype.isEmpty$0 = LinkedHashMapImplementation.prototype.isEmpty;
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
@@ skipping 75 matching lines @@
   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/*const EmptyQueueException()*/);
+  $throw(const$1);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
-  $throw(const$1/*const EmptyQueueException()*/);
+  $throw(const$1);
 }
 // ********** 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);
@@ skipping 33 matching lines @@
 DoubleLinkedQueue.prototype.removeFirst = function() {
   return this._sentinel._next.remove();
 }
 DoubleLinkedQueue.prototype.last = function() {
   return this._sentinel._previous.get$element();
 }
 DoubleLinkedQueue.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue.prototype.get$length = function() {
-  var counter = 0;
+  var counter = (0);
   this.forEach(function _(element) {
     counter++;
   }
   );
   return counter;
 }
 DoubleLinkedQueue.prototype.isEmpty = function() {
-  return (this._sentinel._next === this._sentinel);
+  return (this._sentinel._next == this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while (entry != this._sentinel) {
     var nextEntry = entry._next;
     f(entry._element);
     entry = nextEntry;
   }
 }
 DoubleLinkedQueue.prototype.every = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while (entry != this._sentinel) {
     var nextEntry = entry._next;
     if (!f(entry._element)) return false;
     entry = nextEntry;
   }
   return true;
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while (entry != this._sentinel) {
     var nextEntry = entry._next;
     if (f(entry._element)) return true;
     entry = nextEntry;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
   var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while (entry != this._sentinel) {
     var nextEntry = entry._next;
     if (f(entry._element)) other.addLast(entry._element);
     entry = nextEntry;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator_E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.add$1 = DoubleLinkedQueue.prototype.add;
@@ skipping 24 matching lines @@
   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) {
+  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;
+  return this._currentEntry._next != this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$7/*const NoMoreElementsException()*/);
+    $throw(const$7);
   }
   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;
@@ skipping 21 matching lines @@
   return this.start.bind(this);
 }
 StopwatchImplementation.prototype.stop = function() {
   if (this._start == null) {
     return;
   }
   this._stop = Clock.now();
 }
 StopwatchImplementation.prototype.elapsed = function() {
   if (this._start == null) {
-    return 0;
+    return (0);
   }
   return (this._stop == null) ? (Clock.now() - this._start) : (this._stop - this._start);
 }
 StopwatchImplementation.prototype.elapsedInMs = function() {
-  return $truncdiv((this.elapsed() * 1000), this.frequency());
+  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;
+  return this._length == (0);
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString();
   if (str == null || str.isEmpty()) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $$i = objects.iterator(); $$i.hasNext$0(); ) {
     var obj = $$i.next$0();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new Array();
-  this._length = 0;
+  this._length = (0);
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
-  if (this._buffer.get$length() == 0) return "";
-  if (this._buffer.get$length() == 1) return this._buffer.$index(0);
+  if (this._buffer.get$length() == (0)) return "";
+  if (this._buffer.get$length() == (1)) return this._buffer.$index((0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 StringBufferImpl.prototype.add$1 = StringBufferImpl.prototype.add;
 StringBufferImpl.prototype.addAll$1 = StringBufferImpl.prototype.addAll;
 StringBufferImpl.prototype.isEmpty$0 = StringBufferImpl.prototype.isEmpty;
 StringBufferImpl.prototype.toString$0 = StringBufferImpl.prototype.toString;
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     charCodes = new ListFactory.ListFactory$from$factory(charCodes);
   }
   return String.fromCharCode.apply(null, charCodes);
 }
 StringBase.join = function(strings, separator) {
-  if (strings.get$length() == 0) return "";
-  var s = strings.$index(0);
-  for (var i = 1;
+  if (strings.get$length() == (0)) return "";
+  var s = strings.$index((0));
+  for (var i = (1);
    i < strings.get$length(); i++) {
     s = s + separator + strings.$index(i);
   }
   return s;
 }
 StringBase.concatAll = function(strings) {
   return StringBase.join(strings, "");
 }
 // ********** Code for StringImplementation **************
 StringImplementation = String;
 StringImplementation.prototype.get$length = function() { return this.length; };
 StringImplementation.prototype.endsWith = function(other) {
     'use strict';
     if (other.length > this.length) return false;
     return other == this.substring(this.length - other.length);
 }
 StringImplementation.prototype.startsWith = function(other) {
     'use strict';
     if (other.length > this.length) return false;
     return other == this.substring(0, other.length);
 }
 StringImplementation.prototype.isEmpty = function() {
-  return this.length == 0;
+  return this.length == (0);
 }
 StringImplementation.prototype.contains = function(pattern, startIndex) {
   'use strict'; return this.indexOf(pattern, startIndex) >= 0;
 }
 StringImplementation.prototype._replaceFirst = function(from, to) {
   'use strict';return this.replace(from, to);
 }
 StringImplementation.prototype._replaceRegExp = function(from, to) {
   'use strict';return this.replace(from.re, to);
 }
 StringImplementation.prototype.replaceFirst = function(from, to) {
   if ((typeof(from) == 'string')) return this._replaceFirst(from, to);
   if (!!(from && from.is$RegExp())) return this._replaceRegExp(from, to);
   var $$list = from.allMatches(this);
   for (var $$i = from.allMatches(this).iterator(); $$i.hasNext$0(); ) {
     var match = $$i.next$0();
-    return this.substring(0, match.start$0()) + to + this.substring(match.end$0());
+    return this.substring((0), match.start$0()) + to + this.substring(match.end$0());
   }
 }
 StringImplementation.prototype._replaceAll = function(from, to) {
   'use strict';
   from = new RegExp(from.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), 'g');
   to = to.replace(/\$/g, '$$$$'); // Escape sequences are fun!
   return this.replace(from, to);
 }
 StringImplementation.prototype.replaceAll = function(from, to) {
   if ((typeof(from) == 'string')) return this._replaceAll(from, to);
   if (!!(from && from.is$RegExp())) return this._replaceRegExp(from.get$dynamic().get$_global(), to);
   var buffer = new StringBufferImpl("");
-  var lastMatchEnd = 0;
+  var lastMatchEnd = (0);
   var $$list = from.allMatches(this);
   for (var $$i = from.allMatches(this).iterator(); $$i.hasNext$0(); ) {
     var match = $$i.next$0();
     buffer.add$1(this.substring(lastMatchEnd, match.start$0()));
     buffer.add$1(to);
     lastMatchEnd = match.end$0();
   }
   buffer.add$1(this.substring(lastMatchEnd));
 }
 StringImplementation.prototype.hashCode = function() {
@@ skipping 277 matching lines @@
 function get$process() {
   return new Process(get$_process());
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split("/");
   var $$list = path2.split("/");
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var piece = $$list.$index($$i);
-    if ($eq(piece, "..") && pieces.get$length() > 0 && $ne(pieces.last$0(), ".") && $ne(pieces.last$0(), "..")) {
+    if ($eq(piece, "..") && pieces.get$length() > (0) && $ne(pieces.last$0(), ".") && $ne(pieces.last$0(), "..")) {
       pieces.removeLast$0();
     }
     else if ($ne(piece, "")) {
-      if (pieces.get$length() > 0 && $eq(pieces.last$0(), ".")) {
+      if (pieces.get$length() > (0) && $eq(pieces.last$0(), ".")) {
         pieces.removeLast$0();
       }
       pieces.add$1(piece);
     }
   }
   return Strings.join(pieces, "/");
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf("/", path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == (-1)) {
     return ".";
   }
   else {
-    return path.substring(0, lastSlash);
+    return path.substring((0), lastSlash);
   }
 }
 function basename(path) {
   var lastSlash = path.lastIndexOf("/", path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == (-1)) {
     return path;
   }
   else {
-    return path.substring(lastSlash + 1);
+    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._indentation = (0)
   this._pendingIndent = false
   this.writeComments = true
   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;
+  for (var i = (0);
    i < this._indentation; i++) {
-    this._buf.add("  "/*CodeWriter.INDENTATION*/);
+    this._buf.add("  ");
   }
 }
 CodeWriter.prototype.comment = function(text) {
   if (this.writeComments) {
     this.writeln(text);
   }
 }
 CodeWriter.prototype.write = function(text) {
-  if (text.length == 0) return;
+  if (text.length == (0)) return;
   if (this._pendingIndent) this._indent();
-  if (text.indexOf("\n") != -1) {
+  if (text.indexOf("\n") != (-1)) {
     var lines = text.split("\n");
-    for (var i = 0;
-     i < lines.get$length() - 1; i++) {
+    for (var i = (0);
+     i < lines.get$length() - (1); i++) {
       this.writeln(lines.$index(i));
     }
-    this.write(lines.$index(lines.get$length() - 1));
+    this.write(lines.$index(lines.get$length() - (1)));
   }
   else {
     this._buf.add(text);
   }
 }
 CodeWriter.prototype.writeln = function(text) {
   if (text != null) {
     this.write(text);
   }
-  if (!text.endsWith("\n")) this._buf.add("\n"/*CodeWriter.NEWLINE*/);
+  if (!text.endsWith("\n")) this._buf.add("\n");
   this._pendingIndent = true;
 }
 CodeWriter.prototype.enterBlock = function(text) {
   this.writeln(text);
   this._indentation++;
 }
 CodeWriter.prototype.exitBlock = function(text) {
   this._indentation--;
   this.writeln(text);
 }
@@ skipping 18 matching lines @@
   this._usedOperators = new HashMapImplementation();
   this.writer = new CodeWriter();
   // Initializers done
 }
 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}"/*null._NE_FUNCTION*/;
+      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;
 
     case ":eq":
 
-      code = "function $eq(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}\n// TODO(jimhug): Should this or should it not match equals?\nObject.prototype.$eq = function(other) { return this === other; }"/*null._EQ_FUNCTION*/;
+      code = "function $eq(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}\n// TODO(jimhug): Should this or should it not match equals?\nObject.prototype.$eq = function(other) { return this === other; }";
       break;
 
     case ":bit_not":
 
-      code = "function $bit_not(x) {\n  return (typeof(x) == 'number') ? ~x : x.$bit_not();\n}"/*null._BIT_NOT_FUNCTION*/;
+      code = "function $bit_not(x) {\n  return (typeof(x) == 'number') ? ~x : x.$bit_not();\n}";
       break;
 
     case ":negate":
 
-      code = "function $negate(x) {\n  return (typeof(x) == 'number') ? -x : x.$negate();\n}"/*null._NEGATE_FUNCTION*/;
+      code = "function $negate(x) {\n  return (typeof(x) == 'number') ? -x : x.$negate();\n}";
       break;
 
     case ":add":
 
-      code = "function $add(x, y) {\n  return ((typeof(x) == 'number' && typeof(y) == 'number') ||\n          (typeof(x) == 'string'))\n    ? x + y : x.$add(y);\n}"/*null._ADD_FUNCTION*/;
+      code = "function $add(x, y) {\n  return ((typeof(x) == 'number' && typeof(y) == 'number') ||\n          (typeof(x) == 'string'))\n    ? x + y : x.$add(y);\n}";
       break;
 
     case ":truncdiv":
 
       this.useThrow = true;
-      code = "function $truncdiv(x, y) {\n  if (typeof(x) == 'number' && typeof(y) == 'number') {\n    if (y == 0) $throw(new IntegerDivisionByZeroException());\n    var tmp = x / y;\n    return (tmp < 0) ? Math.ceil(tmp) : Math.floor(tmp);\n  } else {\n    return x.$truncdiv(y);\n  }\n}"/*null._TRUNCDIV_FUNCTION*/;
+      code = "function $truncdiv(x, y) {\n  if (typeof(x) == 'number' && typeof(y) == 'number') {\n    if (y == 0) $throw(new IntegerDivisionByZeroException());\n    var tmp = x / y;\n    return (tmp < 0) ? Math.ceil(tmp) : Math.floor(tmp);\n  } else {\n    return x.$truncdiv(y);\n  }\n}";
       break;
 
     case ":mod":
 
-      code = "function $mod(x, y) {\n  if (typeof(x) == 'number' && typeof(y) == 'number') {\n    var result = x % y;\n    if (result == 0) {\n      return 0;  // Make sure we don't return -0.0.\n    } else if (result < 0) {\n      if (y < 0) {\n        return result - y;\n      } else {\n        return result + y;\n      }\n    }\n    return result;\n  } else {\n    return x.$mod(y);\n  }\n}"/*null._MOD_FUNCTION*/;
+      code = "function $mod(x, y) {\n  if (typeof(x) == 'number' && typeof(y) == 'number') {\n    var result = x % y;\n    if (result == 0) {\n      return 0;  // Make sure we don't return -0.0.\n    } else if (result < 0) {\n      if (y < 0) {\n        return result - y;\n      } else {\n        return result + y;\n      }\n    }\n    return result;\n  } else {\n    return x.$mod(y);\n  }\n}";
       break;
 
     default:
 
       var op = TokenKind.rawOperatorFromMethod(name);
       var jsname = $globals.world.toJsIdentifier(name);
       code = _otherOperator(jsname, op);
       break;
 
   }
   this._usedOperators.$setindex(name, code);
 }
 CoreJs.prototype.ensureDynamicProto = function() {
   if (this._generatedDynamicProto) return;
   this._generatedDynamicProto = true;
   this.ensureTypeNameOf();
-  this.writer.writeln("function $dynamic(name) {\n  var f = Object.prototype[name];\n  if (f && f.methods) return f.methods;\n\n  var methods = {};\n  if (f) methods.Object = f;\n  function $dynamicBind() {\n    // Find the target method\n    var obj = this;\n    var tag = obj.$typeNameOf();\n    var method = methods[tag];\n    if (!method) {\n      var table = $dynamicMetadata;\n      for (var i = 0; i < table.length; i++) {\n        var entry = table[i];\n        if (entry.map.hasOwnProperty(tag)) {\n          method = methods[entry.tag];\n          if (method) break;\n        }\n      }\n    }\n    method = method || methods.Object;\n    // Patch the prototype, but don't overwrite an existing stub, like\n    // the one on Object.prototype.\n    var proto = Object.getPrototypeOf(obj);\n    if (!proto.hasOwnProperty(name)) proto[name] = method;\n\n    return method.apply(this, Array.prototype.slice.call(arguments));\n  };\n  $dynamicBind.methods = methods;\n  Object.prototype[name] = $dynamicBind;\n  return methods;\n}\nif (typeof $dynamicMetadata == 'undefined') $dynamicMetadata = [];\n\nfunction $dynamicSetMetadata(inputTable) {\n  // TODO: Deal with light isolates.\n  var table = [];\n  for (var i = 0; i < inputTable.length; i++) {\n    var tag = inputTable[i][0];\n    var tags = inputTable[i][1];\n    var map = {};\n    var tagNames = tags.split('|');\n    for (var j = 0; j < tagNames.length; j++) {\n      map[tagNames[j]] = true;\n    }\n    table.push({tag: tag, tags: tags, map: map});\n  }\n  $dynamicMetadata = table;\n}\n"/*null._DYNAMIC_FUNCTION*/);
+  this.writer.writeln("function $dynamic(name) {\n  var f = Object.prototype[name];\n  if (f && f.methods) return f.methods;\n\n  var methods = {};\n  if (f) methods.Object = f;\n  function $dynamicBind() {\n    // Find the target method\n    var obj = this;\n    var tag = obj.$typeNameOf();\n    var method = methods[tag];\n    if (!method) {\n      var table = $dynamicMetadata;\n      for (var i = 0; i < table.length; i++) {\n        var entry = table[i];\n        if (entry.map.hasOwnProperty(tag)) {\n          method = methods[entry.tag];\n          if (method) break;\n        }\n      }\n    }\n    method = method || methods.Object;\n    // Patch the prototype, but don't overwrite an existing stub, like\n    // the one on Object.prototype.\n    var proto = Object.getPrototypeOf(obj);\n    if (!proto.hasOwnProperty(name)) proto[name] = method;\n\n    return method.apply(this, Array.prototype.slice.call(arguments));\n  };\n  $dynamicBind.methods = methods;\n  Object.prototype[name] = $dynamicBind;\n  return methods;\n}\nif (typeof $dynamicMetadata == 'undefined') $dynamicMetadata = [];\n\nfunction $dynamicSetMetadata(inputTable) {\n  // TODO: Deal with light isolates.\n  var table = [];\n  for (var i = 0; i < inputTable.length; i++) {\n    var tag = inputTable[i][0];\n    var tags = inputTable[i][1];\n    var map = {};\n    var tagNames = tags.split('|');\n    for (var j = 0; j < tagNames.length; j++) {\n      map[tagNames[j]] = true;\n    }\n    table.push({tag: tag, tags: tags, map: map});\n  }\n  $dynamicMetadata = table;\n}\n");
 }
 CoreJs.prototype.ensureTypeNameOf = function() {
   if (this._generatedTypeNameOf) return;
   this._generatedTypeNameOf = true;
-  this.writer.writeln("Object.prototype.$typeNameOf = function() {\n  if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')\n      || typeof(process) != 'undefined') { // fast-path for Chrome and Node\n    return this.constructor.name;\n  }\n  var str = Object.prototype.toString.call(this);\n  str = str.substring(8, str.length - 1);\n  if (str == 'Window') {\n    str = 'DOMWindow';\n  } else if (str == 'Document') {\n    str = 'HTMLDocument';\n  }\n  return str;\n}"/*null._TYPE_NAME_OF_FUNCTION*/);
+  this.writer.writeln("Object.prototype.$typeNameOf = function() {\n  if ((typeof(window) != 'undefined' && window.constructor.name == 'DOMWindow')\n      || typeof(process) != 'undefined') { // fast-path for Chrome and Node\n    return this.constructor.name;\n  }\n  var str = Object.prototype.toString.call(this);\n  str = str.substring(8, str.length - 1);\n  if (str == 'Window') {\n    str = 'DOMWindow';\n  } else if (str == 'Document') {\n    str = 'HTMLDocument';\n  }\n  return str;\n}");
 }
 CoreJs.prototype.ensureInheritsHelper = function() {
   if (this._generatedInherits) return;
   this._generatedInherits = true;
-  this.writer.writeln("/** Implements extends for Dart classes on JavaScript prototypes. */\nfunction $inherits(child, parent) {\n  if (child.prototype.__proto__) {\n    child.prototype.__proto__ = parent.prototype;\n  } else {\n    function tmp() {};\n    tmp.prototype = parent.prototype;\n    child.prototype = new tmp();\n    child.prototype.constructor = child;\n  }\n}"/*null._INHERITS_FUNCTION*/);
+  this.writer.writeln("/** Implements extends for Dart classes on JavaScript prototypes. */\nfunction $inherits(child, parent) {\n  if (child.prototype.__proto__) {\n    child.prototype.__proto__ = parent.prototype;\n  } else {\n    function tmp() {};\n    tmp.prototype = parent.prototype;\n    child.prototype = new tmp();\n    child.prototype.constructor = child;\n  }\n}");
 }
 CoreJs.prototype.generate = function(w) {
   w.write(this.writer.get$text());
   this.writer = w;
   if (this.useNotNullBool) {
     this.useThrow = true;
-    w.writeln("function $notnull_bool(test) {\n  if (test === true || test === false) return test;\n  $throw(new TypeError(test, 'bool'));\n}"/*null._NOTNULL_BOOL_FUNCTION*/);
+    w.writeln("function $notnull_bool(test) {\n  if (test === true || test === false) return test;\n  $throw(new TypeError(test, 'bool'));\n}");
   }
   if (this.useThrow) {
-    w.writeln("function $throw(e) {\n  // If e is not a value, we can use V8's captureStackTrace utility method.\n  // TODO(jmesserly): capture the stack trace on other JS engines.\n  if (e && (typeof e == 'object') && Error.captureStackTrace) {\n    // TODO(jmesserly): this will clobber the e.stack property\n    Error.captureStackTrace(e, $throw);\n  }\n  throw e;\n}"/*null._THROW_FUNCTION*/);
+    w.writeln("function $throw(e) {\n  // If e is not a value, we can use V8's captureStackTrace utility method.\n  // TODO(jmesserly): capture the stack trace on other JS engines.\n  if (e && (typeof e == 'object') && Error.captureStackTrace) {\n    // TODO(jmesserly): this will clobber the e.stack property\n    Error.captureStackTrace(e, $throw);\n  }\n  throw e;\n}");
   }
   if (this.useIndex) {
-    w.writeln("Object.prototype.$index = function(i) {\n  var proto = Object.getPrototypeOf(this);\n  if (proto !== Object) {\n    proto.$index = function(i) { return this[i]; }\n  }\n  return this[i];\n}\nArray.prototype.$index = function(i) { return this[i]; }\nString.prototype.$index = function(i) { return this[i]; }"/*null._INDEX_OPERATORS*/);
+    w.writeln("Object.prototype.$index = function(i) {\n  var proto = Object.getPrototypeOf(this);\n  if (proto !== Object) {\n    proto.$index = function(i) { return this[i]; }\n  }\n  return this[i];\n}\nArray.prototype.$index = function(i) { return this[i]; }\nString.prototype.$index = function(i) { return this[i]; }");
   }
   if (this.useSetIndex) {
-    w.writeln("Object.prototype.$setindex = function(i, value) {\n  var proto = Object.getPrototypeOf(this);\n  if (proto !== Object) {\n    proto.$setindex = function(i, value) { return this[i] = value; }\n  }\n  return this[i] = value;\n}\nArray.prototype.$setindex = function(i, value) { return this[i] = value; }"/*null._SETINDEX_OPERATORS*/);
+    w.writeln("Object.prototype.$setindex = function(i, value) {\n  var proto = Object.getPrototypeOf(this);\n  if (proto !== Object) {\n    proto.$setindex = function(i, value) { return this[i] = value; }\n  }\n  return this[i] = value;\n}\nArray.prototype.$setindex = function(i, value) { return this[i] = value; }");
   }
   if (this.useIsolates) {
     if (this.useWrap0) {
-      w.writeln("// Wrap a 0-arg dom-callback to bind it with the current isolate:\nfunction $wrap_call$0(fn) { return fn && fn.wrap$call$0(); }\nFunction.prototype.wrap$call$0 = function() {\n  var isolateContext = $globalState.currentContext;\n  var self = this;\n  this.wrap$0 = function() {\n    isolateContext.eval(self);\n    $globalState.topEventLoop.run();\n  };\n  this.wrap$call$0 = function() { return this.wrap$0; };\n  return this.wrap$0;\n}"/*null._WRAP_CALL0_FUNCTION*/);
+      w.writeln("// Wrap a 0-arg dom-callback to bind it with the current isolate:\nfunction $wrap_call$0(fn) { return fn && fn.wrap$call$0(); }\nFunction.prototype.wrap$call$0 = function() {\n  var isolateContext = $globalState.currentContext;\n  var self = this;\n  this.wrap$0 = function() {\n    isolateContext.eval(self);\n    $globalState.topEventLoop.run();\n  };\n  this.wrap$call$0 = function() { return this.wrap$0; };\n  return this.wrap$0;\n}");
     }
     if (this.useWrap1) {
-      w.writeln("// Wrap a 1-arg dom-callback to bind it with the current isolate:\nfunction $wrap_call$1(fn) { return fn && fn.wrap$call$1(); }\nFunction.prototype.wrap$call$1 = function() {\n  var isolateContext = $globalState.currentContext;\n  var self = this;\n  this.wrap$1 = function(arg) {\n    isolateContext.eval(function() { self(arg); });\n    $globalState.topEventLoop.run();\n  };\n  this.wrap$call$1 = function() { return this.wrap$1; };\n  return this.wrap$1;\n}"/*null._WRAP_CALL1_FUNCTION*/);
+      w.writeln("// Wrap a 1-arg dom-callback to bind it with the current isolate:\nfunction $wrap_call$1(fn) { return fn && fn.wrap$call$1(); }\nFunction.prototype.wrap$call$1 = function() {\n  var isolateContext = $globalState.currentContext;\n  var self = this;\n  this.wrap$1 = function(arg) {\n    isolateContext.eval(function() { self(arg); });\n    $globalState.topEventLoop.run();\n  };\n  this.wrap$call$1 = function() { return this.wrap$1; };\n  return this.wrap$1;\n}");
     }
-    w.writeln("var $globalThis = this;\nvar $globals = null;\nvar $globalState = null;"/*null._ISOLATE_INIT_CODE*/);
+    w.writeln("var $globalThis = this;\nvar $globals = null;\nvar $globalState = null;");
   }
   else {
     if (this.useWrap0) {
-      w.writeln("function $wrap_call$0(fn) { return fn; }"/*null._EMPTY_WRAP_CALL0_FUNCTION*/);
+      w.writeln("function $wrap_call$0(fn) { return fn; }");
     }
     if (this.useWrap1) {
-      w.writeln("function $wrap_call$1(fn) { return fn; }"/*null._EMPTY_WRAP_CALL1_FUNCTION*/);
+      w.writeln("function $wrap_call$1(fn) { return fn; }");
     }
   }
   var $$list = orderValuesByKeys(this._usedOperators);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var opImpl = $$list.$index($$i);
     w.writeln(opImpl);
   }
   if ($globals.world.dom != null) {
     this.ensureTypeNameOf();
     w.writeln("Object.prototype.get$typeName =  Object.prototype.$typeNameOf;");
@@ skipping 26 matching lines @@
 Element.prototype.get$jsname = function() {
   return this._jsname;
 }
 Element.prototype.get$nativeName = function() {
   return this._jsname;
 }
 Element.prototype.get$avoidNativeName = function() {
   return false;
 }
 Element.prototype.get$jsnamePriority = function() {
-  return this.get$isNative() ? 2 : (this.get$library().get$isCore() ? 1 : 0);
+  return this.get$isNative() ? (2) : (this.get$library().get$isCore() ? (1) : (0));
 }
 Element.prototype.resolve = function() {
 
 }
 Element.prototype.get$typeParameters = function() {
   return null;
 }
 Element.prototype.get$enclosingElement = function() {
   return this._enclosingElement == null ? this.get$library() : this._enclosingElement;
 }
@@ skipping 31 matching lines @@
     var baseType = this.resolveType(typeRef.baseType, typeErrors);
     if (!baseType.get$isGeneric()) {
       $globals.world.error(("" + baseType.get$name() + " is not generic"), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.get$length() != baseType.get$typeParameters().get$length()) {
       $globals.world.error("wrong number of type arguments", typeRef.span);
       return null;
     }
     var typeArgs = [];
-    for (var i = 0;
+    for (var i = (0);
      i < typeRef.typeArguments.get$length(); i++) {
       typeArgs.add$1(this.resolveType(typeRef.typeArguments.$index(i), typeErrors));
     }
     typeRef.type = baseType.getOrMakeConcreteType$1(typeArgs);
   }
   else if ((node instanceof FunctionTypeReference)) {
     var typeRef = node;
     var name = "";
     if (typeRef.func.name != null) {
       name = typeRef.func.name.name;
@@ skipping 25 matching lines @@
     this.markLibrariesUsed([$globals.world.coreimpl, $globals.world.corelib, this.main.declaringType.get$library()]);
   }
   $globals.world.numImplType.markUsed();
   $globals.world.stringImplType.markUsed();
   if ($globals.world.corelib.types.$index("Isolate").get$isUsed() || $globals.world.coreimpl.types.$index("ReceivePortImpl").get$isUsed()) {
     if (this.corejs.useWrap0 || this.corejs.useWrap1) {
       this.genMethod($globals.world.coreimpl.types.$index("IsolateContext").getMember$1("eval"));
       this.genMethod($globals.world.coreimpl.types.$index("EventLoop").getMember$1("run"));
     }
     this.corejs.useIsolates = true;
-    var isolateMain = $globals.world.coreimpl.topType.resolveMember("startRootIsolate").members.$index(0);
+    var isolateMain = $globals.world.coreimpl.topType.resolveMember("startRootIsolate").members.$index((0));
     var isolateMainTarget = new Value.type$ctor($globals.world.coreimpl.topType, this.main.get$span());
     mainCall = isolateMain.invoke(metaGen, null, isolateMainTarget, new Arguments(null, [this.main._get(metaGen, this.main.definition, null, false)]), false);
   }
   this.writeTypes($globals.world.coreimpl);
   this.writeTypes($globals.world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
   if (this._mixins != null) this.writer.write(this._mixins.get$text());
   this.writeDynamicDispatchMetadata();
   this.writeGlobals();
   this.writer.writeln(("" + mainCall.get$code() + ";"));
@@ skipping 42 matching lines @@
       }).bind(null, lib, toCheck)
       );
       lib.get$types().getValues$0().forEach$1((function (t) {
         return types.add(t);
       })
       );
     }
   }
   return types;
 }
-WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
+WorldGenerator.prototype.globalForStaticField = function(field, exp, dependencies) {
   this.hasStatics = true;
-  var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
-  if (!this.globals.containsKey(fullname)) {
-    this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
+  var key = ("" + field.declaringType.get$jsname() + "." + field.get$jsname());
+  var ret = this.globals.$index(key);
+  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 this.globals.$index(fullname);
+  return ret;
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
-  var key = exp.get$type().get$jsname() + ":" + exp.canonicalCode;
-  if (!this.globals.containsKey(key)) {
-    this.globals.$setindex(key, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
+  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());
+    ret = new GlobalValue(exp.get$type(), name, true, null, name, exp, exp.span, dependencies);
+    this.globals.$setindex(key, ret);
   }
-  return this.globals.$index(key);
+  return ret;
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if (lib.isWritten) return;
   lib.isWritten = true;
   var $$list = lib.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var import_ = $$list.$index($$i);
     this.writeTypes(import_.get$library());
   }
-  for (var i = 0;
+  for (var i = (0);
    i < lib.sources.get$length(); i++) {
     lib.sources.$index(i).set$orderInLibrary(i);
   }
   this.writer.comment(("//  ********** Library " + lib.name + " **************"));
   if (lib.get$isCore()) {
     this.writer.comment("//  ********** Natives dart:core **************");
     this.corejs.generate(this.writer);
   }
   var $$list = lib.natives;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var file = $$list.$index($$i);
     var filename = basename(file.get$filename());
     this.writer.comment(("//  ********** Natives " + filename + " **************"));
     this.writer.writeln(file.get$text());
   }
   lib.topType.markUsed();
   var $$list = this._orderValues(lib.types);
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var type = $$list.$index($$i);
     if ((type.get$isUsed() || type.get$library().get$isDom() || type.get$isHiddenNativeType()) && type.get$isClass()) {
       this.writeType(type);
       if (type.get$isGeneric()) {
         var $list0 = this._orderValues(type.get$_concreteTypes());
         for (var $i0 = 0;$i0 < $list0.get$length(); $i0++) {
           var ct = $list0.$index($i0);
           this.writeType(ct);
         }
       }
     }
-    else if (type.get$isFunction() && type.get$varStubs().get$length() > 0) {
+    else if (type.get$isFunction() && type.get$varStubs().get$length() > (0)) {
       this.writer.comment(("// ********** Code for " + type.get$jsname() + " **************"));
       this._writeDynamicStubs(type);
     }
     if (type.get$typeCheckCode() != null) {
       this.writer.writeln(type.get$typeCheckCode());
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
   if (!meth.isGenerated && !meth.get$isAbstract() && meth.get$definition() != null) {
@@ skipping 71 matching lines @@
     }
     else if (!type.get$isNative()) {
       if (type.get$parent() != null && !type.get$parent().get$isObject()) {
         this.corejs.ensureInheritsHelper();
         this.writer.writeln(("$inherits(" + type.get$jsname() + ", " + type.get$parent().get$jsname() + ");"));
       }
     }
   }
   if (type.get$isTop()) {
   }
-  else if (type.get$constructors().get$length() == 0) {
+  else if (type.get$constructors().get$length() == (0)) {
     if (!type.get$isNative()) {
       this.writer.writeln(("function " + type.get$jsname() + "() {}"));
     }
   }
   else {
     var standardConstructor = type.get$constructors().$index("");
     if (standardConstructor == null || standardConstructor.generator == null) {
       if (!type.get$isNative()) {
         this.writer.writeln(("function " + type.get$jsname() + "() {}"));
       }
@@ skipping 131 matching lines @@
     m.generator.writeDefinition(this.writer, null);
   }
   else if ((m instanceof MethodMember) && m.get$isNative() && m._providePropertySyntax && !m._provideFieldSyntax) {
     MethodGenerator._maybeGenerateBoundGetter(m, this.writer);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return this._writeMethod.bind(this);
 }
 WorldGenerator.prototype.writeGlobals = function() {
-  if (this.globals.get$length() > 0) {
+  if (this.globals.get$length() > (0)) {
     this.writer.comment("//  ********** Globals **************");
     var list = this.globals.getValues();
     list.sort$1((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     this.writer.enterBlock("function $static_init(){");
     for (var $$i = list.iterator$0(); $$i.hasNext$0(); ) {
       var global = $$i.next$0();
       if (global.get$field() != null) {
         this._writeStaticField(global.get$field());
       }
     }
     this.writer.exitBlock("}");
     for (var $$i = list.iterator$0(); $$i.hasNext$0(); ) {
       var global = $$i.next$0();
       if (global.get$field() == null) {
         this.writer.writeln(("var " + global.get$name() + " = " + global.get$exp().get$code() + ";"));
       }
     }
   }
   if (!this.corejs.useIsolates) {
     if (this.hasStatics) {
       this.writer.writeln("var $globals = {};");
     }
-    if (this.globals.get$length() > 0) {
+    if (this.globals.get$length() > (0)) {
       this.writer.writeln("$static_init();");
     }
   }
 }
 WorldGenerator.prototype._usedDynamicDispatchOnType = function(type) {
   if (this.typesWithDynamicDispatch == null) this.typesWithDynamicDispatch = new HashSetImplementation();
   this.typesWithDynamicDispatch.add(type);
 }
 WorldGenerator.prototype.writeDynamicDispatchMetadata = function() {
   var $this = this; // closure support
@@ skipping 52 matching lines @@
             tagDefns.$setindex(tag, varName);
             expressions.add$1(varName);
           }
         }
       }
     }
     walk(type);
     var constantPart = ("'" + Strings.join(subtags, "|") + "'");
     if ($ne(constantPart, "''")) expressions.add$1(constantPart);
     var expression;
-    if ($eq(expressions.get$length(), 1)) {
-      expression = expressions.$index(0);
+    if ($eq(expressions.get$length(), (1))) {
+      expression = expressions.$index((0));
     }
     else {
       expression = ("[" + Strings.join(expressions, ",") + "].join('|')");
     }
     return expression;
   }
   for (var $$i = dispatchTypes.iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     tagDefns.$setindex(type.get$nativeName(), makeExpression(type));
   }
@@ skipping 20 matching lines @@
   return values;
 }
 WorldGenerator.prototype._orderCollectionValues = function(collection) {
   var values = ListFactory.ListFactory$from$factory(collection);
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
   if (x.get$span() != null && y.get$span() != null) {
     var spans = x.get$span().compareTo$1(y.get$span());
-    if (spans != 0) return spans;
+    if (spans != (0)) return spans;
   }
-  if (x.get$span() == null) return 1;
-  if (y.get$span() == null) return -1;
+  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.parent = parent;
   this.reentrant = reentrant;
@@ skipping 57 matching lines @@
   var type = this.enclosingMethod.method.declaringType;
   if (type.get$library().lookup(name, null) != null) return true;
   return false;
 }
 BlockScope.prototype.create = function(name, type, span, isFinal, isParameter) {
   var jsName = $globals.world.toJsIdentifier(name);
   if (this._vars.containsKey(name)) {
     $globals.world.error(("duplicate name \"" + name + "\""), span);
   }
   if (!isParameter) {
-    var index = 0;
+    var index = (0);
     while (this._isDefinedInParent(jsName)) {
       jsName = ("" + name + (index++));
     }
   }
   var ret = new Value(type, jsName, span, false);
   ret.set$isFinal(isFinal);
   this._vars.$setindex(name, ret);
   if (name != jsName) this._jsNames.add(jsName);
   return ret;
 }
@@ skipping 44 matching lines @@
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return value.needsTemp ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
-  if (this._freeTemps.get$length() > 0) {
+  if (this._freeTemps.get$length() > (0)) {
     name = this._freeTemps.removeLast();
   }
   else {
     name = "$" + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
   return new Value(value.get$type(), name, value.span, false);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
   if ($eq(tmp, v)) {
     return v;
   }
   else {
-    return new Value(v.get$type(), ("(" + tmp.code + " = " + v.code + ")"), v.span, true);
+    return new Value(v.get$type(), ("(" + tmp.get$code() + " = " + v.get$code() + ")"), v.span, true);
   }
 }
 MethodGenerator.prototype.freeTemp = function(value) {
-  if (this._usedTemps.remove(value.code)) {
-    this._freeTemps.add(value.code);
+  if (this._usedTemps.remove(value.get$code())) {
+    this._freeTemps.add(value.get$code());
   }
   else {
-    $globals.world.internalError(("tried to free unused value or non-temp \"" + value.code + "\""));
+    $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();
   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();
       })
       );
       this.writer.write(this.method.get$definition().get$nativeBody());
     }
   }
 }
 MethodGenerator.prototype.writeDefinition = function(defWriter, lambda) {
   var paramCode = this._paramCode;
   var names = null;
-  if (this.captures != null && this.captures.get$length() > 0) {
+  if (this.captures != null && this.captures.get$length() > (0)) {
     names = ListFactory.ListFactory$from$factory(this.captures);
     names.sort$1((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     paramCode = ListFactory.ListFactory$from$factory(names);
     paramCode.addAll$1(this._paramCode);
   }
   var _params = ("(" + Strings.join(this._paramCode, ", ") + ")");
   var params = ("(" + Strings.join(paramCode, ", ") + ")");
@@ skipping 29 matching lines @@
   }
   else if (this.method.get$isStatic()) {
     defWriter.enterBlock(("" + this.method.declaringType.get$jsname() + "." + this.method.get$jsname() + " = function" + _params + " {"));
   }
   else {
     defWriter.enterBlock($globals.world.gen._prototypeOf(this.method.declaringType, this.method.get$jsname()) + (" = function" + _params + " {"));
   }
   if (this.needsThis) {
     defWriter.writeln("var $this = this; // closure support");
   }
-  if (this._usedTemps.get$length() > 0 || this._freeTemps.get$length() > 0) {
+  if (this._usedTemps.get$length() > (0) || this._freeTemps.get$length() > (0)) {
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo$1(y);
     })
     );
     defWriter.writeln(("var " + Strings.join(this._freeTemps, ", ") + ";"));
   }
   defWriter.writeln(this.writer.get$text());
   if (names != null) {
     defWriter.exitBlock(("}).bind(null, " + Strings.join(names, ", ") + ")"));
@@ skipping 30 matching lines @@
       var optValues = [];
       meth.genParameterValues();
       var $$list = meth.parameters;
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
         var param = $$list.$index($$i);
         if (param.get$isOptional()) {
           optNames.add$1(param.get$name());
           optValues.add$1(MethodGenerator._escapeString(param.get$value().get$code()));
         }
       }
-      if (optNames.get$length() > 0) {
+      if (optNames.get$length() > (0)) {
         var start = "";
         if (meth.isStatic) {
           if (!meth.declaringType.get$isTop()) {
             start = meth.declaringType.get$jsname() + ".";
           }
         }
         else {
           start = meth.declaringType.get$jsname() + ".prototype.";
         }
         optNames.addAll$1(optValues);
@@ skipping 57 matching lines @@
     }
     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;
         }
-        else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.get$op().get$kind()) == 0) {
+        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;
           }
@@ skipping 13 matching lines @@
   }
   if (this.method.get$isConstructor() && initializerCall == null && !this.method.get$isNative()) {
     var parentType = this.method.declaringType.get$parent();
     if (parentType != null && !parentType.get$isObject()) {
       initializerCall = new CallExpression(new SuperExpression(this.method.get$span()), [], this.method.get$span());
     }
   }
   if (initializerCall != null) {
     var target = this._writeInitializerCall(initializerCall);
     if (!target.get$isSuper()) {
-      if (initializers.get$length() > 0) {
+      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);
+      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());
@@ skipping 51 matching lines @@
     }
     else if (seenLabel) {
       $globals.world.error("bare argument can not follow named arguments", arg.get$span());
     }
     args.add$1(this.visitValue(arg.get$value()));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator.prototype._invokeNative = function(name, arguments) {
   var args = Arguments.get$EMPTY();
-  if (arguments.get$length() > 0) {
+  if (arguments.get$length() > (0)) {
     args = new Arguments(null, arguments);
   }
   var method = $globals.world.corelib.topType.members.$index(name);
   return method.invoke$4(this, method.get$definition(), new Value($globals.world.corelib.topType, null, null, true), args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r");
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
   if ((body instanceof BlockStatement)) {
@@ skipping 48 matching lines @@
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
   var parser = new Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
-  if (node.modifiers != null && $eq(node.modifiers.$index(0).get$kind(), 98/*TokenKind.FINAL*/)) {
+  if (node.modifiers != null && $eq(node.modifiers.$index((0)).get$kind(), (98))) {
     isFinal = true;
   }
   this.writer.write("var ");
   var type = this.method.resolveType(node.type, false);
-  for (var i = 0;
+  for (var i = (0);
    i < node.names.get$length(); i++) {
     var thisType = type;
-    if (i > 0) {
+    if (i > (0)) {
       this.writer.write(", ");
     }
     var name = node.names.$index(i).get$name();
     var value = this.visitValue(node.values.$index(i));
     if (isFinal) {
       if (value == null) {
         $globals.world.error("no value specified for final variable", node.span);
       }
       else {
         if (thisType.get$isVar()) thisType = value.get$type();
@@ skipping 51 matching lines @@
     else {
       this.writer.writeln(("throw " + rethrow.get$code() + ";"));
     }
   }
   return true;
 }
 MethodGenerator.prototype.visitAssertStatement = function(node) {
   var test = this.visitValue(node.test);
   if ($globals.options.enableAsserts) {
     var span = node.test.span;
-    var line = span.get$file().getLine$1(span.get$start()) + 1;
-    var column = span.get$file().getColumn$2(line - 1, span.get$start()) + 1;
+    var line = span.get$file().getLine$1(span.get$start()) + (1);
+    var column = span.get$file().getColumn$2(line - (1), span.get$start()) + (1);
     var args = [test, Value.fromString(span.get$text(), node.span), Value.fromString(span.get$file().get$filename(), node.span), Value.fromInt(line, node.span), Value.fromInt(column, node.span)];
     var tp = $globals.world.corelib.topType;
     var f = tp.getMember$1("_assert");
     var value = f.invoke(this, node, new Value.type$ctor(tp, null), new Arguments(null, args), false);
     this.writer.writeln(("" + value.get$code() + ";"));
   }
   return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
   if (node.label == null) {
@@ skipping 79 matching lines @@
 MethodGenerator.prototype.visitForInStatement = function(node) {
   var itemType = this.method.resolveType(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
   var isFinal = this._isFinal(node.item.type);
   var item = this._scope.create(itemName, itemType, node.item.name.span, isFinal, false);
   var listVar = list;
   if (list.get$needsTemp()) {
     listVar = this._scope.create("$list", list.get$type(), null, false, false);
-    this.writer.writeln(("var " + listVar.code + " = " + list.get$code() + ";"));
+    this.writer.writeln(("var " + listVar.get$code() + " = " + list.get$code() + ";"));
   }
   if (list.get$type().get$isList()) {
     var tmpi = this._scope.create("$i", $globals.world.numType, null, false, false);
     var listLength = listVar.get_(this, "length", node.list);
     this.writer.enterBlock(("for (var " + tmpi.get$code() + " = 0;") + ("" + tmpi.get$code() + " < " + listLength.get$code() + "; " + tmpi.get$code() + "++) {"));
     var value = listVar.invoke(this, ":index", node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(("var " + item.get$code() + " = " + value.get$code() + ";"));
   }
   else {
     var iterator = list.invoke$4(this, "iterator", node.list, Arguments.get$EMPTY());
     var tmpi = this._scope.create("$i", iterator.get$type(), null, false, false);
     var hasNext = tmpi.invoke$4(this, "hasNext", node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, "next", node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(("for (var " + tmpi.get$code() + " = " + iterator.get$code() + "; " + hasNext.get$code() + "; ) {"));
     this.writer.writeln(("var " + item.get$code() + " = " + next.get$code() + ";"));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock("}");
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex) {
   var result = this._invokeNative("_toDartException", [ex]);
-  this.writer.writeln(("" + ex.code + " = " + result.get$code() + ";"));
+  this.writer.writeln(("" + ex.get$code() + " = " + result.get$code() + ";"));
 }
 MethodGenerator.prototype._genStackTraceOf = function(trace, ex) {
   var result = this._invokeNative("_stackTraceOf", [ex]);
-  this.writer.writeln(("var " + trace.code + " = " + result.get$code() + ";"));
+  this.writer.writeln(("var " + trace.get$code() + " = " + result.get$code() + ";"));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock("try {");
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
-  if (node.catches.get$length() == 1) {
-    var catch_ = node.catches.$index(0);
+  if (node.catches.get$length() == (1)) {
+    var catch_ = node.catches.$index((0));
     this._pushBlock(false);
     var exType = this.method.resolveType(catch_.get$exception().get$type(), false);
     var ex = this._scope.declare(catch_.get$exception());
     this._scope.rethrow = ex;
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     if (catch_.get$trace() != null) {
       var trace = this._scope.declare(catch_.get$trace());
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     if (!exType.get$isVarOrObject()) {
       var test = ex.instanceOf$3$isTrue$forceCheck(this, exType, catch_.get$exception().get$span(), false, true);
       this.writer.writeln(("if (" + test.get$code() + ") throw " + ex.get$code() + ";"));
     }
-    this.visitStatementsInBlock(node.catches.$index(0).get$body());
+    this.visitStatementsInBlock(node.catches.$index((0)).get$body());
     this._popBlock();
   }
-  else if (node.catches.get$length() > 0) {
+  else if (node.catches.get$length() > (0)) {
     this._pushBlock(false);
     var ex = this._scope.create("$ex", $globals.world.varType, null, false, false);
     this._scope.rethrow = ex;
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     var trace = null;
     if (node.catches.some((function (c) {
       return c.get$trace() != null;
     })
     )) {
       trace = this._scope.create("$trace", $globals.world.varType, null, false, false);
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     var needsRethrow = true;
-    for (var i = 0;
+    for (var i = (0);
      i < node.catches.get$length(); i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
       var tmpType = this.method.resolveType(catch_.get$exception().get$type(), false);
       var tmp = this._scope.declare(catch_.get$exception());
       if (!tmpType.get$isVarOrObject()) {
         var test = ex.instanceOf$3$isTrue$forceCheck(this, tmpType, catch_.get$exception().get$span(), true, true);
-        if (i == 0) {
+        if (i == (0)) {
           this.writer.enterBlock(("if (" + test.get$code() + ") {"));
         }
         else {
           this.writer.nextBlock(("} else if (" + test.get$code() + ") {"));
         }
       }
-      else if (i > 0) {
+      else if (i > (0)) {
         this.writer.nextBlock("} else {");
       }
       this.writer.writeln(("var " + tmp.get$code() + " = " + ex.get$code() + ";"));
       if (catch_.get$trace() != null) {
         var tmptrace = this._scope.declare(catch_.get$trace());
         this.writer.writeln(("var " + tmptrace.get$code() + " = " + trace.get$code() + ";"));
       }
       this.visitStatementsInBlock(catch_.get$body());
       this._popBlock();
       if (tmpType.get$isVarOrObject()) {
-        if (i + 1 < node.catches.get$length()) {
-          $globals.world.error("Unreachable catch clause", node.catches.$index(i + 1).get$span());
+        if (i + (1) < node.catches.get$length()) {
+          $globals.world.error("Unreachable catch clause", node.catches.$index(i + (1)).get$span());
         }
-        if (i > 0) {
+        if (i > (0)) {
           this.writer.exitBlock("}");
         }
         needsRethrow = false;
         break;
       }
     }
     if (needsRethrow) {
       this.writer.nextBlock("} else {");
       this.writer.writeln(("throw " + ex.get$code() + ";"));
       this.writer.exitBlock("}");
@@ skipping 12 matching lines @@
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
   var test = this.visitValue(node.test);
   this.writer.enterBlock(("switch (" + test.get$code() + ") {"));
   var $$list = node.cases;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var case_ = $$list.$index($$i);
     if (case_.get$label() != null) {
       $globals.world.error("unimplemented: labeled case statement", case_.get$span());
     }
     this._pushBlock(false);
-    for (var i = 0;
+    for (var i = (0);
      i < case_.get$cases().get$length(); i++) {
       var expr = case_.get$cases().$index(i);
       if (expr == null) {
-        if (i < case_.get$cases().get$length() - 1) {
+        if (i < case_.get$cases().get$length() - (1)) {
           $globals.world.error("default clause must be the last case", case_.get$span());
         }
         this.writer.writeln("default:");
       }
       else {
         var value = this.visitValue(expr);
         this.writer.writeln(("case " + value.get$code() + ":"));
       }
     }
     this.writer.enterBlock("");
     var caseExits = this._visitAllStatements(case_.get$statements(), false);
-    if ($ne(case_, node.cases.$index(node.cases.get$length() - 1)) && !caseExits) {
-      var span = case_.get$statements().$index(case_.get$statements().get$length() - 1).get$span();
+    if ($ne(case_, node.cases.$index(node.cases.get$length() - (1))) && !caseExits) {
+      var span = case_.get$statements().$index(case_.get$statements().get$length() - (1)).get$span();
       this.writer.writeln("$throw(new FallThroughError());");
       $globals.world.gen.corejs.useThrow = true;
     }
     this.writer.exitBlock("");
     this._popBlock();
   }
   this.writer.exitBlock("}");
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
-  for (var i = 0;
+  for (var i = (0);
    i < statementList.get$length(); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit$1(this);
-    if ($ne(stmt, statementList.$index(statementList.get$length() - 1)) && exits) {
-      $globals.world.warning("unreachable code", statementList.$index(i + 1).get$span());
+    if ($ne(stmt, statementList.$index(statementList.get$length() - (1))) && exits) {
+      $globals.world.warning("unreachable code", statementList.$index(i + (1)).get$span());
     }
   }
   return exits;
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock("{");
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock("}");
   this._popBlock();
@@ skipping 71 matching lines @@
   var w = new CodeWriter();
   meth.generator.writeDefinition(w, node);
   return new Value(meth.get$functionType(), w.get$text(), node.span, true);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
   var target;
   var position = node.target;
   var name = ":call";
   if ((node.target instanceof DotExpression)) {
     var dot = node.target;
-    if ((dot.self instanceof LiteralExpression)) {
-      target = (new ParenExpression(dot.self, dot.self.span)).visit(this);
-    }
-    else {
-      target = dot.self.visit(this);
-    }
+    target = dot.self.visit(this);
     name = dot.name.name;
     position = dot.name;
   }
   else if ((node.target instanceof VarExpression)) {
     var varExpr = node.target;
     name = varExpr.name.name;
     target = this._scope.lookup(name);
     if (target != null) {
       return target.invoke$4(this, ":call", node, this._makeArgs(node.arguments));
     }
     target = this._makeThisOrType(varExpr.span);
     return target.invoke$4(this, name, node, this._makeArgs(node.arguments));
   }
   else {
     target = node.target.visit(this);
   }
   return target.invoke$4(this, name, position, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitIndexExpression = function(node) {
   var target = this.visitValue(node.target);
   var index = this.visitValue(node.index);
   return target.invoke$4(this, ":index", node, new Arguments(null, [index]));
 }
 MethodGenerator.prototype._expressionNeedsParens = function(e) {
   return ((e instanceof BinaryExpression) || (e instanceof ConditionalExpression) || (e instanceof PostfixExpression) || this._isUnaryIncrement(e));
 }
 MethodGenerator.prototype.visitBinaryExpression = function(node, isVoid) {
   var kind = node.op.kind;
-  if (kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/) {
+  if (kind == (35) || kind == (34)) {
     var x = this.visitTypedValue(node.x, $globals.world.nonNullBool);
     var y = this.visitTypedValue(node.y, $globals.world.nonNullBool);
-    var code = ("" + x.get$code() + " " + node.op + " " + y.get$code());
-    if (x.get$isConst() && y.get$isConst()) {
-      var value = (kind == 35/*TokenKind.AND*/) ? x.get$actualValue() && y.get$actualValue() : x.get$actualValue() || y.get$actualValue();
-      return Value.fromBool(value, node.span);
-    }
-    return new Value($globals.world.nonNullBool, code, node.span, true);
+    return x.binop$4(kind, y, this, node);
   }
-  else if (kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/) {
+  else if (kind == (50) || kind == (51)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
-    if (x.get$isConst() && y.get$isConst()) {
-      var xVal = x.get$actualValue();
-      var yVal = y.get$actualValue();
-      var value = kind == 50/*TokenKind.EQ_STRICT*/ ? $eq(xVal, yVal) : $ne(xVal, yVal);
-      return Value.fromBool(value, node.span);
-    }
-    if ($eq(x.get$code(), "null") || $eq(y.get$code(), "null")) {
-      var op = node.op.toString().substring(0, 2);
-      return new Value($globals.world.nonNullBool, ("" + x.get$code() + " " + op + " " + y.get$code()), node.span, true);
-    }
-    else {
-      return new Value($globals.world.nonNullBool, ("" + x.get$code() + " " + node.op + " " + y.get$code()), node.span, true);
-    }
+    return x.binop$4(kind, y, this, node);
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
-  if (assignKind == -1) {
+  if (assignKind == (-1)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
-    var name = TokenKind.binaryMethodName(node.op.kind);
-    if (node.op.kind == 49/*TokenKind.NE*/) {
-      name = ":ne";
-    }
-    if (name == null) {
-      $globals.world.internalError(("unimplemented binary op " + node.op), node.span);
-      return;
-    }
-    return x.invoke$4(this, name, node, new Arguments(null, [y]));
+    return x.binop$4(kind, y, this, node);
   }
-  else if ((assignKind != 0) && this._expressionNeedsParens(node.y)) {
+  else if ((assignKind != (0)) && this._expressionNeedsParens(node.y)) {
     return this._visitAssign(assignKind, node.x, new ParenExpression(node.y, node.y.span), node, to$call$1(null), isVoid);
   }
   else {
     return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null), isVoid);
   }
 }
 MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
   if (captureOriginal == null) {
     captureOriginal = (function (x) {
       return x;
@@ skipping 17 matching lines @@
   var name = xn.name.name;
   var x = this._scope.lookup(name);
   var y = this.visitValue(yn);
   if (x == null) {
     var members = this.method.declaringType.resolveMember(name);
     x = this._makeThisOrType(position.span);
     if (members != null) {
       if ($globals.options.forceDynamic && !members.get$isStatic()) {
         members = this.findMembers(xn.name.name);
       }
-      if (kind == 0) {
+      if (kind == (0)) {
         return x.set_$4(this, name, position, y);
       }
       else if (!members.get$treatAsField() || members.get$containsMethods()) {
         var right = x.get_$3(this, name, position);
         right = captureOriginal(right);
         y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
         return x.set_$4(this, name, position, y);
       }
       else {
         x = x.get_$3(this, name, position);
       }
     }
     else {
       var member = this.get$library().lookup(name, xn.name.span);
       if (member == null) {
         $globals.world.warning(("can not resolve " + name), xn.span);
         return this._makeMissingValue(name);
       }
       members = new MemberSet(member, false);
       if (!members.get$treatAsField() || members.get$containsMethods()) {
-        if (kind != 0) {
+        if (kind != (0)) {
           var right = members._get$3(this, position, x);
           right = captureOriginal(right);
           y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
         }
         return members._set$4(this, position, x, y);
       }
       else {
         x = members._get$3(this, position, x);
       }
     }
   }
   if (x.get$isFinal()) {
     $globals.world.error(("final variable \"" + x.get$code() + "\" is not assignable"), position.span);
   }
   y = y.convertTo$2(this, x.get$type());
-  if (kind == 0) {
+  if (kind == (0)) {
     x = captureOriginal(x);
     return new Value(y.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span, true);
   }
-  else if (x.get$type().get$isNum() && y.get$type().get$isNum() && (kind != 46/*TokenKind.TRUNCDIV*/)) {
+  else if (x.get$type().get$isNum() && y.get$type().get$isNum() && (kind != (46))) {
     x = captureOriginal(x);
     var op = TokenKind.kindToString(kind);
     return new Value(y.get$type(), ("" + x.get$code() + " " + op + "= " + y.get$code()), position.span, true);
   }
   else {
     var right = x;
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
     return new Value(y.get$type(), ("" + x.get$code() + " = " + y.get$code()), position.span, true);
   }
 }
 MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal, isVoid) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
-  if (kind != 0) {
+  if (kind != (0)) {
     tmptarget = this.getTemp(target);
     tmpindex = this.getTemp(index);
     index = this.assignTemp(tmpindex, index);
     var right = tmptarget.invoke$4(this, ":index", position, new Arguments(null, [tmpindex]));
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
   var tmpy = null;
   if (!isVoid) {
     tmpy = this.getTemp(y);
     y = this.assignTemp(tmpy, y);
   }
   var ret = this.assignTemp(tmptarget, target).invoke(this, ":setindex", position, new Arguments(null, [index, y]), false);
   if (tmpy != null) {
     ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpy.get$code() + ")"), ret.get$span(), true);
     if ($ne(tmpy, y)) this.freeTemp(tmpy);
   }
   if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
   if ($ne(tmpindex, index)) this.freeTemp(tmpindex);
   return ret;
 }
 MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = xn.self.visit(this);
   var y = this.visitValue(yn);
   var tmptarget = target;
-  if (kind != 0) {
+  if (kind != (0)) {
     tmptarget = this.getTemp(target);
     var right = tmptarget.get_$3(this, xn.name.name, xn.name);
     right = captureOriginal(right);
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
   var ret = this.assignTemp(tmptarget, target).set_(this, xn.name.name, xn.name, y, false);
   if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
   return ret;
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
-    case 16/*TokenKind.INCR*/:
-    case 17/*TokenKind.DECR*/:
+    case (16):
+    case (17):
 
       if (value.get$type().get$isNum()) {
         return new Value(value.get$type(), ("" + node.op + value.get$code()), node.span, true);
       }
       else {
-        var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
-        var operand = new LiteralExpression(Value.fromInt(1, node.span), node.span);
+        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/*TokenKind.NOT*/:
+    case (19):
 
       if (value.get$type().get$isBool() && value.get$isConst()) {
         var newVal = !value.get$actualValue();
-        return EvaluatedValue.EvaluatedValue$factory(value.get$type(), newVal, ("" + newVal), node.span);
+        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/*TokenKind.ADD*/:
+    case (42):
 
       return value.convertTo$2(this, $globals.world.numType);
 
-    case 43/*TokenKind.SUB*/:
-    case 18/*TokenKind.BIT_NOT*/:
+    case (43):
+    case (18):
 
-      if (node.op.kind == 18/*TokenKind.BIT_NOT*/) {
+      if (node.op.kind == (18)) {
         return value.invoke$4(this, ":bit_not", node, Arguments.get$EMPTY());
       }
-      else if (node.op.kind == 43/*TokenKind.SUB*/) {
+      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);
 
   }
 }
 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);
   if (value.get$type().get$isNum() && !value.get$isFinal()) {
     return new Value(value.get$type(), ("" + value.get$code() + node.op), node.span, true);
   }
-  var kind = (16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
-  var operand = new LiteralExpression(Value.fromInt(1, node.span), node.span);
+  var kind = ((16) == node.op.kind) ? (42) : (43);
+  var operand = new LiteralExpression(Value.fromInt((1), node.span), node.span);
   var tmpleft = null, left = null;
   var ret = this._visitAssign(kind, node.body, operand, node, (function (l) {
     if (isVoid) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp(l);
       return $this.assignTemp(tmpleft, left);
     }
   })
   , false);
   if (tmpleft != null) {
     ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpleft.get$code() + ")"), node.span, true);
   }
   if ($ne(tmpleft, left)) {
     this.freeTemp(tmpleft);
   }
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var typeRef = node.type;
   var constructorName = "";
   if (node.name != null) {
     constructorName = node.name.name;
   }
   if ($eq(constructorName, "") && !(typeRef instanceof GenericTypeReference) && typeRef.get$names() != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.get$names());
     constructorName = names.removeLast$0().get$name();
-    if ($eq(names.get$length(), 0)) names = null;
+    if ($eq(names.get$length(), (0))) names = null;
     typeRef = new NameTypeReference(typeRef.get$isFinal(), typeRef.get$name(), names, typeRef.get$span());
   }
   var type = this.method.resolveType(typeRef, true);
   if (type.get$isTop()) {
     type = type.get$library().findTypeByName$1(constructorName);
     constructorName = "";
   }
   if ((type instanceof ParameterType)) {
     $globals.world.error("cannot instantiate a type parameter", node.span);
     return this._makeMissingValue(constructorName);
@@ skipping 16 matching lines @@
       var arg = $$list.$index($$i);
       if (!this.visitValue(arg.get$value()).get$isConst()) {
         $globals.world.error("const constructor expects const arguments", arg.get$span());
       }
     }
   }
   var target = new Value.type$ctor(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
-  var argsCode = [];
   var argValues = [];
-  var type = null;
-  if (node.type != null) {
-    type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(0);
+  var listType = $globals.world.listType;
+  var type = $globals.world.varType;
+  if (node.itemType != null) {
+    type = this.method.resolveType(node.itemType, true);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const list literals");
     }
+    listType = listType.getOrMakeConcreteType$1([type]);
   }
   var $$list = node.values;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var item = $$list.$index($$i);
     var arg = this.visitTypedValue(item, type);
     argValues.add$1(arg);
-    if (node.isConst) {
-      if (!arg.get$isConst()) {
-        $globals.world.error("const list can only contain const values", item.get$span());
-        argsCode.add$1(arg.get$code());
-      }
-      else {
-        argsCode.add$1(arg.get$canonicalCode());
-      }
-    }
-    else {
-      argsCode.add$1(arg.get$code());
+    if (node.isConst && !arg.get$isConst()) {
+      $globals.world.error("const list can only contain const values", arg.get$span());
     }
   }
   $globals.world.listFactoryType.markUsed();
-  var code = ("[" + Strings.join(argsCode, ", ") + "]");
-  var value = new Value($globals.world.listType, code, node.span, true);
-  if (node.isConst) {
-    var immutableList = $globals.world.immutableListType;
-    var immutableListCtor = immutableList.getConstructor("from");
-    var result = immutableListCtor.invoke$4(this, node, new Value.type$ctor(value.get$type(), node.span), new Arguments(null, [value]));
-    value = $globals.world.gen.globalForConst(ConstListValue.ConstListValue$factory(immutableList, argValues, ("const " + code), result.get$code(), node.span), argValues);
-  }
-  return value;
+  var ret = new ListValue(argValues, node.isConst, listType, node.span);
+  if (ret.get$isConst()) return ret.getGlobalValue$0();
+  return ret;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
-  if (node.items.get$length() == 0 && !node.isConst) {
+  if (node.items.get$length() == (0) && !node.isConst) {
     return $globals.world.mapType.getConstructor("").invoke$4(this, node, new Value.type$ctor($globals.world.mapType, node.span), Arguments.get$EMPTY());
   }
-  var argValues = [];
-  var argsCode = [];
-  var type = null;
-  if (node.type != null) {
-    type = this.method.resolveType(node.type, true).get$typeArgsInOrder().$index(1);
-    if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
+  var values = new Array();
+  var valueType = $globals.world.varType, keyType = $globals.world.stringType;
+  var mapType = $globals.world.mapType;
+  if (node.valueType != null) {
+    if (node.keyType != null) {
+      keyType = this.method.resolveType(node.keyType, true);
+      if (!keyType.get$isString()) {
+        $globals.world.error("the key type of a map literal must be \"String\"", keyType.get$span());
+      }
+      if (node.isConst && ((keyType instanceof ParameterType) || keyType.get$hasTypeParams())) {
+        $globals.world.error("type parameter cannot be used in const map literals");
+      }
+    }
+    valueType = this.method.resolveType(node.valueType, true);
+    if (node.isConst && ((valueType instanceof ParameterType) || valueType.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const map literals");
     }
+    mapType = mapType.getOrMakeConcreteType$1([keyType, valueType]);
   }
-  for (var i = 0;
-   i < node.items.get$length(); i += 2) {
-    var key = this.visitTypedValue(node.items.$index(i), $globals.world.stringType);
-    var valueItem = node.items.$index(i + 1);
-    var value = this.visitTypedValue(valueItem, type);
-    argValues.add$1(key);
-    argValues.add$1(value);
-    if (node.isConst) {
-      if (!key.get$isConst() || !value.get$isConst()) {
-        $globals.world.error("const map can only contain const values", valueItem.get$span());
-        argsCode.add$1(key.get$code());
-        argsCode.add$1(value.get$code());
-      }
-      else {
-        argsCode.add$1(key.get$canonicalCode());
-        argsCode.add$1(value.get$canonicalCode());
-      }
+  for (var i = (0);
+   i < node.items.get$length(); i += (2)) {
+    var key = this.visitTypedValue(node.items.$index(i), keyType);
+    if (node.isConst && !key.get$isConst()) {
+      $globals.world.error("const map can only contain const keys", key.get$span());
     }
-    else {
-      argsCode.add$1(key.get$code());
-      argsCode.add$1(value.get$code());
+    values.add$1(key);
+    var value = this.visitTypedValue(node.items.$index(i + (1)), valueType);
+    if (node.isConst && !value.get$isConst()) {
+      $globals.world.error("const map can only contain const values", value.get$span());
     }
+    values.add$1(value);
   }
-  var argList = ("[" + Strings.join(argsCode, ", ") + "]");
-  var items = new Value($globals.world.listType, argList, node.span, true);
-  var tp = $globals.world.corelib.topType;
-  var f = node.isConst ? tp.getMember$1("_constMap") : tp.getMember$1("_map");
-  var value = f.invoke(this, node, new Value.type$ctor(tp, null), new Arguments(null, [items]), false);
-  if (node.isConst) {
-    value = ConstMapValue.ConstMapValue$factory(value.get$type(), argValues, value.get$code(), value.get$code(), value.get$span());
-    return $globals.world.gen.globalForConst(value, argValues);
-  }
-  else {
-    return value;
-  }
+  var ret = new MapValue(values, node.isConst, mapType, node.span);
+  if (ret.get$isConst()) return ret.getGlobalValue$0();
+  return ret;
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ("" + test.get$code() + " ? " + trueBranch.get$code() + " : " + falseBranch.get$code());
   return new Value(Type.union(trueBranch.get$type(), falseBranch.get$type()), code, node.span, true);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type, false);
   return value.instanceOf$4(this, type, node.span, node.isTrue);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var body = this.visitValue(node.body);
-  if (body.get$isConst()) {
-    return EvaluatedValue.EvaluatedValue$factory(body.get$type(), body.get$actualValue(), ("(" + body.get$canonicalCode() + ")"), node.span);
-  }
+  if (body.get$isConst()) return body;
   return new Value(body.get$type(), ("(" + body.get$code() + ")"), node.span, true);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_$3(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var name = node.name.name;
   var ret = this._scope.lookup(name);
   if (ret != null) return ret;
@@ skipping 10 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   return node.value;
 }
 MethodGenerator.prototype._isUnaryIncrement = function(item) {
   if ((item instanceof UnaryExpression)) {
     var u = item;
-    return u.op.kind == 16/*TokenKind.INCR*/ || u.op.kind == 17/*TokenKind.DECR*/;
+    return u.op.kind == (16) || u.op.kind == (17);
   }
   else {
     return false;
   }
 }
 MethodGenerator.prototype.visitStringInterpExpression = function(node) {
   var items = [];
   var $$list = node.pieces;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var item = $$list.$index($$i);
     var val = this.visitValue(item);
     val.invoke$4(this, "toString", item, Arguments.get$EMPTY());
     var code = val.get$code();
     if (this._expressionNeedsParens(item)) {
       code = ("(" + code + ")");
     }
-    if ($eq(items.get$length(), 0) || ($ne(code, "''") && $ne(code, "\"\""))) {
+    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.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;
+  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() {
   if ($globals.Arguments__empty == null) {
     $globals.Arguments__empty = new Arguments(null, []);
   }
   return $globals.Arguments__empty;
 }
-Arguments.prototype.get$values = function() { return this.values; };
-Arguments.prototype.set$values = function(value) { return this.values = value; };
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
 Arguments.prototype.get$hasNames = function() {
   return this.get$bareCount() < this.get$length();
 }
 Arguments.prototype.get$length = function() {
   return this.values.get$length();
 }
 Arguments.prototype.getName = function(i) {
   return this.nodes.$index(i).get$label().get$name();
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     if (this.getName(i) == name) {
       return i;
     }
   }
-  return -1;
+  return (-1);
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
-  return i >= 0 ? this.values.$index(i) : null;
+  return i >= (0) ? this.values.$index(i) : null;
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
-      for (var i = 0;
+      for (var i = (0);
        i < this.nodes.get$length(); i++) {
         if (this.nodes.$index(i).get$label() != null) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
-  for (var i = 0;
+  for (var i = (0);
    i < this.get$length(); i++) {
     argsCode.add$1(this.values.$index(i).get$code());
   }
   Arguments.removeTrailingNulls(argsCode);
   return Strings.join(argsCode, ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
-  while (argsCode.get$length() > 0 && $eq(argsCode.last(), "null")) {
+  while (argsCode.get$length() > (0) && $eq(argsCode.last(), "null")) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     names.add$1(this.getName(i));
   }
   return names;
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
-  for (var i = 0;
+  for (var i = (0);
    i < this.get$bareCount(); i++) {
     result.add$1(new Value($globals.world.varType, ("$" + i), null, false));
   }
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     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);
@@ skipping 44 matching lines @@
 Library.prototype.get$isCore = function() {
   return $eq(this, $globals.world.corelib);
 }
 Library.prototype.get$isCoreImpl = function() {
   return $eq(this, $globals.world.coreimpl);
 }
 Library.prototype.get$isDom = function() {
   return $eq(this, $globals.world.dom);
 }
 Library.prototype.get$span = function() {
-  return new SourceSpan(this.baseSource, 0, 0);
+  return new SourceSpan(this.baseSource, (0), (0));
 }
 Library.prototype.makeFullPath = function(filename) {
   if (filename.startsWith("dart:")) return filename;
   if (filename.startsWith("/")) return filename;
   if (filename.startsWith("file:///")) return filename;
   if (filename.startsWith("http://")) return filename;
   return joinPaths(this.sourceDir, filename);
 }
 Library.prototype.addImport = function(fullname, prefix) {
   var newLib = $globals.world.getOrAddLibrary(fullname);
@@ skipping 62 matching lines @@
   }
   else {
     this.types.$setindex(name, new DefinedType(name, this, definition, isClass));
   }
   return this.types.$index(name);
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if (result == null) return null;
   if (type.names != null) {
-    if (type.names.get$length() > 1) {
+    if (type.names.get$length() > (1)) {
       return null;
     }
     if (!result.get$isTop()) {
       return null;
     }
-    return result.get$library().findTypeByName(type.names.$index(0).get$name());
+    return result.get$library().findTypeByName(type.names.$index((0)).get$name());
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name) {
   var ret = this.types.$index(name);
   var $$list = this.imports;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var imported = $$list.$index($$i);
     var newRet = null;
     if (imported.get$prefix() == null) {
@@ skipping 71 matching lines @@
         }
       }
     }
   }
   return ret;
 }
 Library.prototype.resolve = function() {
   if (this.name == null) {
     this.name = this.baseSource.filename;
     var index = this.name.lastIndexOf("/", this.name.length);
-    if (index >= 0) {
-      this.name = this.name.substring(index + 1);
+    if (index >= (0)) {
+      this.name = this.name.substring(index + (1));
     }
     index = this.name.indexOf(".");
-    if (index > 0) {
-      this.name = this.name.substring(0, index);
+    if (index > (0)) {
+      this.name = this.name.substring((0), index);
     }
   }
   this._jsname = this.name.replaceAll(".", "_").replaceAll(":", "_").replaceAll(" ", "_");
   var $$list = this.types.getValues();
   for (var $$i = this.types.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var type = $$i.next$0();
     type.resolve$0();
   }
 }
 Library.prototype.visitSources = function() {
@@ skipping 47 matching lines @@
 _LibraryVisitor.prototype.addSource = function(source) {
   var $this = this; // closure support
   if (this.library.sources.some((function (s) {
     return $eq(s.get$filename(), source.filename);
   })
   )) {
     $globals.world.error(("duplicate source file \"" + source.filename + "\""));
     return;
   }
   this.library.sources.add(source);
-  var parser = new Parser(source, $globals.options.dietParse, false, false, 0);
+  var parser = new Parser(source, $globals.options.dietParse, false, false, (0));
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit$1($this);
   })
   );
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $$i = newSources.iterator$0(); $$i.hasNext$0(); ) {
     var source0 = $$i.next$0();
@@ skipping 22 matching lines @@
       else {
         $globals.world.error("already specified library name", node.span);
       }
       break;
 
     case "import":
 
       this.seenImport = true;
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, "prefix");
-      if (node.arguments.get$length() > 2 || node.arguments.get$length() == 2 && prefix == null) {
+      if (node.arguments.get$length() > (2) || node.arguments.get$length() == (2) && prefix == null) {
         $globals.world.error("expected at most one \"name\" argument and one optional \"prefix\"" + (" but found " + node.arguments.get$length()), node.span);
       }
-      else if (prefix != null && prefix.indexOf$1(".") >= 0) {
+      else if (prefix != null && prefix.indexOf$1(".") >= (0)) {
         $globals.world.error("library prefix canot contain \".\"", node.span);
       }
       else if (this.seenSource || this.seenResource) {
         $globals.world.error("#imports must come before any #source or #resource", node.span);
       }
       if ($eq(prefix, "")) prefix = null;
       var filename = this.library.makeFullPath(name);
       if (this.library.imports.some((function (li) {
         return $eq(li.get$library().get$baseSource(), filename);
       })
@@ skipping 26 matching lines @@
       this.getFirstStringArg(node);
       break;
 
     default:
 
       $globals.world.error(("unknown directive: " + node.name.name), node.span);
 
   }
 }
 _LibraryVisitor.prototype.getSingleStringArg = function(node) {
-  if (node.arguments.get$length() != 1) {
+  if (node.arguments.get$length() != (1)) {
     $globals.world.error(("expected exactly one argument but found " + node.arguments.get$length()), node.span);
   }
   return this.getFirstStringArg(node);
 }
 _LibraryVisitor.prototype.getFirstStringArg = function(node) {
-  if (node.arguments.get$length() < 1) {
+  if (node.arguments.get$length() < (1)) {
     $globals.world.error(("expected at least one argument but found " + node.arguments.get$length()), node.span);
   }
-  var arg = node.arguments.$index(0);
+  var arg = node.arguments.$index((0));
   if (arg.get$label() != null) {
     $globals.world.error("label not allowed for directive", node.span);
   }
   return this._parseStringArgument(arg);
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var args = node.arguments.filter((function (a) {
     return a.get$label() != null && $eq(a.get$label().get$name(), argName);
   })
   );
-  if ($eq(args.get$length(), 0)) {
+  if ($eq(args.get$length(), (0))) {
     return null;
   }
-  if (args.get$length() > 1) {
+  if (args.get$length() > (1)) {
     $globals.world.error(("expected at most one \"" + argName + "\" argument but found ") + node.arguments.get$length(), node.span);
   }
   for (var $$i = args.iterator$0(); $$i.hasNext$0(); ) {
     var arg = $$i.next$0();
     return this._parseStringArgument(arg);
   }
 }
 _LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
   if (!(expr instanceof LiteralExpression) || !expr.get$value().get$type().get$isString()) {
@@ skipping 37 matching lines @@
 Parameter.prototype.set$name = function(value) { return this.name = value; };
 Parameter.prototype.get$type = function() { return this.type; };
 Parameter.prototype.set$type = function(value) { return this.type = value; };
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
 Parameter.prototype.set$isInitializer = function(value) { return this.isInitializer = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function() {
   this.name = this.definition.name.name;
   if (this.name.startsWith("this.")) {
-    this.name = this.name.substring(5);
+    this.name = this.name.substring((5));
     this.isInitializer = true;
   }
   this.type = this.method.resolveType(this.definition.type, false);
   if (this.definition.value != null) {
     if (this.definition.value.span.start == this.definition.span.start) {
       return;
     }
     if (this.method.name == ":call") {
       if (this.method.get$definition().get$body() == null && !this.method.get$isNative()) {
         $globals.world.error("default value not allowed on function type", this.definition.span);
@@ skipping 143 matching lines @@
 Member.prototype.get$generatedFactoryName = function() {
   var prefix = ("" + this.declaringType.get$jsname() + "." + this.get$constructorName() + "$");
   if (this.name == "") {
     return ("" + prefix + "factory");
   }
   else {
     return ("" + prefix + this.name + "$factory");
   }
 }
 Member.prototype.hashCode = function() {
-  var typeCode = this.declaringType == null ? 1 : this.declaringType.hashCode();
+  var typeCode = this.declaringType == null ? (1) : this.declaringType.hashCode();
   var nameCode = this.get$isConstructor() ? this.get$constructorName().hashCode() : this.name.hashCode();
-  return (typeCode << 4) ^ nameCode;
+  return (typeCode << (4)) ^ nameCode;
 }
 Member.prototype.$eq = function(other) {
   return (other instanceof Member) && $eq(this.get$isConstructor(), other.get$isConstructor()) && $eq(this.declaringType, other.get$declaringType()) && (this.get$isConstructor() ? this.get$constructorName() == other.get$constructorName() : this.name == other.get$name());
 }
 Member.prototype._get$3 = Member.prototype._get;
 Member.prototype._get$3$isDynamic = Member.prototype._get;
 Member.prototype._get$4 = Member.prototype._get;
 Member.prototype._set$4 = Member.prototype._set;
 Member.prototype._set$4$isDynamic = Member.prototype._set;
 Member.prototype._set$5 = Member.prototype._set;
@@ skipping 112 matching lines @@
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
-      if ($eq(mod.get$kind(), 84/*TokenKind.STATIC*/)) {
+      if ($eq(mod.get$kind(), (84))) {
         if (this.isStatic) {
           $globals.world.error("duplicate static modifier", mod.get$span());
         }
         this.isStatic = true;
       }
-      else if ($eq(mod.get$kind(), 98/*TokenKind.FINAL*/)) {
+      else if ($eq(mod.get$kind(), (98))) {
         if (this.isFinal) {
           $globals.world.error("duplicate final modifier", mod.get$span());
         }
         this.isFinal = true;
       }
       else {
         $globals.world.error(("" + mod + " modifier not allowed on field"), mod.get$span());
       }
     }
   }
@@ skipping 61 matching lines @@
     else if (this.declaringType.get$isNative()) {
       if (this.declaringType.get$isHiddenNativeType()) {
         $globals.world.error("static field of hidden native type is inaccessible", node.span);
       }
       return new Value(this.type, ("" + this.declaringType.get$jsname() + "." + this.get$jsname()), node.span, true);
     }
     else {
       return new Value(this.type, ("$globals." + this.declaringType.get$jsname() + "_" + this.get$jsname()), node.span, true);
     }
   }
-  else if (target.get$isConst() && this.isFinal) {
-    var constTarget = (target instanceof GlobalValue) ? target.get$dynamic().get$exp() : target;
-    if ((constTarget instanceof ConstObjectValue)) {
-      return constTarget.get$fields().$index(this.name);
-    }
-    else if ($eq(constTarget.get$type(), $globals.world.stringType) && this.name == "length") {
-      return new Value(this.type, ("" + constTarget.get$actualValue().get$length()), node.span, true);
-    }
-  }
-  return new Value(this.type, ("" + target.code + "." + this.get$jsname()), node.span, true);
+  return new Value(this.type, ("" + target.get$code() + "." + this.get$jsname()), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, isDynamic);
-  return new Value(this.type, ("" + lhs.get$code() + " = " + value.code), node.span, true);
+  return new Value(this.type, ("" + lhs.get$code() + " = " + value.get$code()), node.span, true);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
 FieldMember.prototype._get$3$isDynamic = FieldMember.prototype._get;
 FieldMember.prototype._get$4 = FieldMember.prototype._get;
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set($0, $1, $2, $3, false);
 };
 FieldMember.prototype._set$4$isDynamic = FieldMember.prototype._set;
@@ skipping 79 matching lines @@
   }
   else {
     parent = parentMember;
   }
   if (this.getter == null) this.getter = parent.getter;
   if (this.setter == null) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function() {
   if (this.getter != null) {
     this.getter.resolve();
-    if (this.getter.parameters.get$length() != 0) {
+    if (this.getter.parameters.get$length() != (0)) {
       $globals.world.error("getter methods should take no arguments", this.getter.definition.span);
     }
     if (this.getter.returnType.get$isVoid()) {
       $globals.world.warning("getter methods should not be void", this.getter.definition.returnType.span);
     }
   }
   if (this.setter != null) {
     this.setter.resolve();
-    if (this.setter.parameters.get$length() != 1) {
+    if (this.setter.parameters.get$length() != (1)) {
       $globals.world.error("setter methods should take a single argument", this.setter.definition.span);
     }
     if (!this.setter.returnType.get$isVoid() && this.setter.definition.returnType != null) {
       $globals.world.warning("setter methods should be void", this.setter.definition.returnType.span);
     }
   }
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
@@ skipping 106 matching lines @@
   return type.resolveTypeParams$1(this.declaringType);
 }
 ConcreteMember.prototype.computeValue = function() {
   return this.baseMember.computeValue();
 }
 ConcreteMember.prototype.override = function(other) {
   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.code, node.span, true);
+  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.code, node.span, true);
+  return new Value(this.returnType, ret.get$code(), node.span, true);
 }
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
-  var code = ret.code;
+  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._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
@@ skipping 66 matching lines @@
 MethodMember.prototype.get$span = function() {
   return this.definition == null ? null : this.definition.span;
 }
 MethodMember.prototype.get$constructorName = function() {
   var returnType = this.definition.returnType;
   if (returnType == null) return "";
   if ((returnType instanceof GenericTypeReference)) {
     return "";
   }
   if (returnType.get$names() != null) {
-    return returnType.get$names().$index(0).get$name();
+    return returnType.get$names().$index((0)).get$name();
   }
   else if (returnType.get$name() != null) {
     return returnType.get$name().get$name();
   }
   $globals.world.internalError("no valid constructor name", this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
   if (this._functionType == null) {
     this._functionType = this.get$library().getOrAddFunctionType(this.declaringType, this.name, this.definition);
     if (this.parameters == null) {
@@ skipping 15 matching lines @@
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
   if (bareCount > this.parameters.get$length()) return false;
   if (bareCount == this.parameters.get$length()) {
     if (bareCount != args.get$length()) return false;
   }
   else {
     if (!this.parameters.$index(bareCount).get$isOptional()) return false;
     for (var i = bareCount;
      i < args.get$length(); i++) {
-      if (this.indexOfParameter(args.getName(i)) < 0) {
+      if (this.indexOfParameter(args.getName(i)) < (0)) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name) {
-  for (var i = 0;
+  for (var i = (0);
    i < this.parameters.get$length(); i++) {
     var p = this.parameters.$index(i);
     if (p.get$isOptional() && $eq(p.get$name(), name)) {
       return i;
     }
   }
-  return -1;
+  return (-1);
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
   this._providePropertySyntax = true;
 }
 MethodMember.prototype._set = function(context, node, target, value, isDynamic) {
   $globals.world.error("cannot set method", node.span);
 }
 MethodMember.prototype._get = function(context, node, target, isDynamic) {
   this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
   if (this.isStatic) {
     this.declaringType.markUsed();
     var type = this.declaringType.get$isTop() ? "" : ("" + this.declaringType.get$jsname() + ".");
     return new Value(this.get$functionType(), ("" + type + this.get$jsname()), node.span, true);
   }
   this._providePropertySyntax = true;
-  return new Value(this.get$functionType(), ("" + target.code + ".get$" + this.get$jsname() + "()"), node.span, true);
+  return new Value(this.get$functionType(), ("" + target.get$code() + ".get$" + this.get$jsname() + "()"), node.span, true);
 }
 MethodMember.prototype.namesInHomePositions = function(args) {
   if (!args.get$hasNames()) return true;
   for (var i = args.get$bareCount();
    i < args.values.get$length(); i++) {
     if (i >= this.parameters.get$length()) {
       return false;
     }
     if (args.getName(i) != this.parameters.$index(i).get$name()) {
       return false;
     }
   }
   return true;
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!args.get$hasNames()) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
    i < this.parameters.get$length(); i++) {
     var p = args.getIndexOfName(this.parameters.$index(i).get$name());
-    if (p >= 0 && args.values.$index(p).get$needsTemp()) {
+    if (p >= (0) && args.values.$index(p).get$needsTemp()) {
       if (lastParameter != null && lastParameter > p) {
         return false;
       }
       lastParameter = p;
     }
   }
   return true;
 }
 MethodMember.prototype.needsArgumentConversion = function(args) {
   var bareCount = args.get$bareCount();
-  for (var i = 0;
+  for (var i = (0);
    i < bareCount; i++) {
     var arg = args.values.$index(i);
     if (arg.needsConversion$1(this.parameters.$index(i).get$type())) {
       return true;
     }
   }
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
@@ skipping 42 matching lines @@
   }
   if (this.get$isNative() && this.returnType != null) this.returnType.markUsed();
   if (!this.namesInOrder(args)) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
   if (!target.isType && (this.get$isConstructor() || target.isSuper)) {
     argsCode.add$1("this");
   }
   var bareCount = args.get$bareCount();
-  for (var i = 0;
+  for (var i = (0);
    i < bareCount; i++) {
     var arg = args.values.$index(i);
     if (i >= this.parameters.get$length()) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.get$length(), false);
       return this._argError(context, node, target, args, msg, i);
     }
     arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
-    if (this.isConst && arg.get$isConst()) {
-      argsCode.add$1(arg.get$canonicalCode());
-    }
-    else {
-      argsCode.add$1(arg.get$code());
-    }
+    argsCode.add$1(arg.get$code());
   }
-  var namedArgsUsed = 0;
+  var namedArgsUsed = (0);
   if (bareCount < this.parameters.get$length()) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.get$length(); i++) {
       var arg = args.getValue(this.parameters.$index(i).get$name());
       if (arg == null) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
         arg = arg.convertTo$3(context, this.parameters.$index(i).get$type(), isDynamic);
         namedArgsUsed++;
       }
       if (arg == null || !this.parameters.$index(i).get$isOptional()) {
-        var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
+        var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + (1), true);
         return this._argError(context, node, target, args, msg, i);
       }
       else {
-        argsCode.add$1(this.isConst && arg.get$isConst() ? arg.get$canonicalCode() : arg.get$code());
+        argsCode.add$1(arg.get$code());
       }
     }
     Arguments.removeTrailingNulls(argsCode);
   }
   if (namedArgsUsed < args.get$nameCount()) {
     var seen = new HashSetImplementation();
     for (var i = bareCount;
      i < args.get$length(); i++) {
       var name = args.getName(i);
       if (seen.contains$1(name)) {
         return this._argError(context, node, target, args, ("duplicate argument \"" + name + "\""), i);
       }
       seen.add$1(name);
       var p = this.indexOfParameter(name);
-      if (p < 0) {
+      if (p < (0)) {
         return this._argError(context, node, target, args, ("method does not have optional parameter \"" + name + "\""), i);
       }
       else if (p < bareCount) {
         return this._argError(context, node, target, args, ("argument \"" + name + "\" passed as positional and named"), p);
       }
     }
     $globals.world.internalError(("wrong named arguments calling " + this.name), node.span);
   }
   var argsString = Strings.join(argsCode, ", ");
   if (this.get$isConstructor()) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
   if (target.isSuper) {
     return new Value(this.get$inferredResult(), ("" + this.declaringType.get$jsname() + ".prototype." + this.get$jsname() + ".call(" + argsString + ")"), node.span, true);
   }
   if (this.get$isOperator()) {
     return this._invokeBuiltin(context, node, target, args, argsCode, isDynamic);
   }
   if (this.isFactory) {
-    return new Value(target.get$type(), ("" + this.get$generatedFactoryName() + "(" + argsString + ")"), node.span, true);
+    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 : node, true);
+      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.code + "." + this.get$jsname() + "(" + argsString + ")");
-  if (target.get$isConst()) {
-    if ((target instanceof GlobalValue)) {
-      target = target.get$dynamic().get$exp();
-    }
-    if (this.name == "get:length") {
-      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
-        code = ("" + target.get$dynamic().get$values().get$length());
-      }
-    }
-    else if (this.name == "isEmpty") {
-      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
-        code = ("" + target.get$dynamic().get$values().isEmpty$0());
-      }
-    }
-  }
+  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();
   }
   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");
   if (!target.isType) {
     var code = ("" + this.declaringType.get$nativeName() + ctor + ".call(" + argsString + ")");
     return new Value(target.get$type(), code, node.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);
     }
     else {
       var span = node != null ? node.span : target.span;
       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;
+  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;
+    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();
@@ skipping 37 matching lines @@
     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(ConstObjectValue.ConstObjectValue$factory(target.get$type(), fields, code, node.span), args.values);
+  return $globals.world.gen.globalForConst(new ObjectValue(fields, true, target.get$type(), code, node.span), args.values);
 }
 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.code);
+        code = ("-" + target.get$code());
       }
       else if (this.name == ":bit_not") {
-        code = ("~" + target.code);
+        code = ("~" + target.get$code());
       }
       else if (this.name == ":truncdiv" || this.name == ":mod") {
         $globals.world.gen.corejs.useOperator(this.name);
-        code = ("" + this.get$jsname() + "(" + target.code + ", " + argsCode.$index(0) + ")");
+        code = ("" + this.get$jsname() + "(" + target.get$code() + ", " + argsCode.$index((0)) + ")");
       }
       else {
         var op = TokenKind.rawOperatorFromMethod(this.name);
-        code = ("" + target.code + " " + op + " " + argsCode.$index(0));
+        code = ("" + target.get$code() + " " + op + " " + argsCode.$index((0)));
       }
       return new Value(this.get$inferredResult(), code, node.span, true);
     }
     else {
       var value;
       var val0, val1, ival0, ival1;
       val0 = target.get$dynamic().get$actualValue();
       ival0 = val0.toInt();
-      if (args.values.get$length() > 0) {
-        val1 = args.values.$index(0).get$dynamic().get$actualValue();
+      if (args.values.get$length() > (0)) {
+        val1 = args.values.$index((0)).get$dynamic().get$actualValue();
         ival1 = val1.toInt();
       }
       switch (this.name) {
         case ":negate":
 
           value = -val0;
           break;
 
         case ":add":
 
@@ skipping 84 matching lines @@
 
           value = (ival0 >> ival1).toDouble();
           break;
 
         case ":shr":
 
           value = (ival0 >>> ival1).toDouble();
           break;
 
       }
-      return EvaluatedValue.EvaluatedValue$factory(this.get$inferredResult(), value, ("" + value), node.span);
+      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);
+      }
     }
   }
   else if (this.declaringType.get$isString()) {
     if (this.name == ":index") {
-      return new Value(this.declaringType, ("" + target.code + "[" + argsCode.$index(0) + "]"), node.span, true);
+      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();
+        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.code + " + " + argsCode.$index(0)), node.span, true);
+      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.code + "[" + argsCode.$index(0) + "]"), node.span, true);
+      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.code + "[" + argsCode.$index(0) + "] = " + argsCode.$index(1)), node.span, true);
+      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 val1 = args.values.$index((0)).get$dynamic().get$actualValue();
       var newVal = this.name == ":eq" ? $eq(val0, val1) : $ne(val0, val1);
-      return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, newVal, ("" + newVal), node.span);
+      return Value.fromBool(newVal, node.span);
     }
-    if ($eq(argsCode.$index(0), "null")) {
-      return new Value(this.get$inferredResult(), ("" + target.code + " " + op + " null"), node.span, true);
+    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.code + " " + op + " " + argsCode.$index(0)), node.span, true);
+      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.code + ", " + argsCode.$index(0) + ")"), node.span, true);
+    return new Value(this.get$inferredResult(), ("" + this.get$jsname() + "(" + target.get$code() + ", " + argsCode.$index((0)) + ")"), node.span, true);
   }
   if (this.get$isCallMethod()) {
     this.declaringType.markUsed();
-    return new Value(this.get$inferredResult(), ("" + target.code + "(" + Strings.join(argsCode, ", ") + ")"), node.span, true);
+    return new Value(this.get$inferredResult(), ("" + target.get$code() + "(" + Strings.join(argsCode, ", ") + ")"), node.span, true);
   }
   if (this.name == ":index") {
     $globals.world.gen.corejs.useIndex = true;
   }
   else if (this.name == ":setindex") {
     $globals.world.gen.corejs.useSetIndex = true;
   }
   var argsString = Strings.join(argsCode, ", ");
-  return new Value(this.get$inferredResult(), ("" + target.code + "." + this.get$jsname() + "(" + argsString + ")"), node.span, true);
+  return new Value(this.get$inferredResult(), ("" + target.get$code() + "." + this.get$jsname() + "(" + argsString + ")"), node.span, true);
 }
 MethodMember.prototype.resolve = function() {
   this.isStatic = this.declaringType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !this.declaringType.get$isClass();
   if (this.definition.modifiers != null) {
     var $$list = this.definition.modifiers;
     for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
       var mod = $$list.$index($$i);
-      if ($eq(mod.get$kind(), 84/*TokenKind.STATIC*/)) {
+      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/*TokenKind.CONST*/)) {
+      else if (this.get$isConstructor() && $eq(mod.get$kind(), (91))) {
         if (this.isConst) {
           $globals.world.error("duplicate const modifier", mod.get$span());
         }
         this.isConst = true;
       }
-      else if ($eq(mod.get$kind(), 73/*TokenKind.FACTORY*/)) {
+      else if ($eq(mod.get$kind(), (73))) {
         if (this.isFactory) {
           $globals.world.error("duplicate factory modifier", mod.get$span());
         }
         this.isFactory = true;
       }
-      else if ($eq(mod.get$kind(), 71/*TokenKind.ABSTRACT*/)) {
+      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());
           }
         }
         this.isAbstract = true;
       }
@@ skipping 84 matching lines @@
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
     return (m instanceof MethodMember);
   })
   );
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
-  return this.members.get$length() == 1 && this.members.$index(0).get$isStatic();
+  return this.members.get$length() == (1) && this.members.$index((0)).get$isStatic();
 }
 MemberSet.prototype.get$isOperator = function() {
-  return this.members.$index(0).get$isOperator();
+  return this.members.$index((0)).get$isOperator();
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if (!target.get$type().get$isVar()) {
     $globals.world.warning(("could not find applicable " + action + " for \"" + this.name + "\""), node.span);
   }
-  return new Value($globals.world.varType, ("" + target.code + "." + this.jsname + "() /*no applicable " + action + "*/"), node.span, true);
+  return new Value($globals.world.varType, ("" + target.get$code() + "." + this.jsname + "() /*no applicable " + action + "*/"), node.span, true);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if (this._treatAsField == null) {
     this._treatAsField = !this.isVar && (this.members.some((function (m) {
       return m.get$requiresFieldSyntax();
     })
     ) || this.members.every((function (m) {
       return !m.get$requiresPropertySyntax();
     })
     ));
@@ skipping 17 matching lines @@
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._get$3$isDynamic(context, node, target, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span, true);
   }
   else {
-    if (this.members.get$length() == 1) {
-      return this.members.$index(0)._get$4(context, node, target, isDynamic);
+    if (this.members.get$length() == (1)) {
+      return this.members.$index((0))._get$4(context, node, target, isDynamic);
     }
-    else if ($eq(targets.get$length(), 1)) {
-      return targets.$index(0)._get$4(context, node, target, isDynamic);
+    else if ($eq(targets.get$length(), (1))) {
+      return targets.$index((0))._get$4(context, node, target, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
       var value = member._get$3$isDynamic(context, node, target, true);
       returnValue = this._tryUnion(returnValue, value, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "getter");
     }
   }
-  if (returnValue.code == null) {
+  if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
-      return new Value(returnValue.get$type(), ("" + target.code + "." + this.jsname), node.span, true);
+      return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname), node.span, true);
     }
     else {
-      return new Value(returnValue.get$type(), ("" + target.code + ".get$" + this.jsname + "()"), node.span, true);
+      return new Value(returnValue.get$type(), ("" + target.get$code() + ".get$" + this.jsname + "()"), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
   var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
   if (this.isVar) {
     targets.forEach$1((function (m) {
       return m._set$4$isDynamic(context, node, target, value, true);
     })
     );
     returnValue = new Value(this._foldTypes(targets), null, node.span, true);
   }
   else {
-    if (this.members.get$length() == 1) {
-      return this.members.$index(0)._set$5(context, node, target, value, isDynamic);
+    if (this.members.get$length() == (1)) {
+      return this.members.$index((0))._set$5(context, node, target, value, isDynamic);
     }
-    else if ($eq(targets.get$length(), 1)) {
-      return targets.$index(0)._set$5(context, node, target, value, isDynamic);
+    else if ($eq(targets.get$length(), (1))) {
+      return targets.$index((0))._set$5(context, node, target, value, isDynamic);
     }
     for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
       var member = $$i.next$0();
       var res = member._set$4$isDynamic(context, node, target, value, true);
       returnValue = this._tryUnion(returnValue, res, node);
     }
     if (returnValue == null) {
       return this._makeError(node, target, "setter");
     }
   }
-  if (returnValue.code == null) {
+  if (returnValue.get$code() == null) {
     if (this.get$treatAsField()) {
-      return new Value(returnValue.get$type(), ("" + target.code + "." + this.jsname + " = " + value.code), node.span, true);
+      return new Value(returnValue.get$type(), ("" + target.get$code() + "." + this.jsname + " = " + value.get$code()), node.span, true);
     }
     else {
-      return new Value(returnValue.get$type(), ("" + target.code + ".set$" + this.jsname + "(" + value.code + ")"), node.span, true);
+      return new Value(returnValue.get$type(), ("" + target.get$code() + ".set$" + this.jsname + "(" + value.get$code() + ")"), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
   if (this.isVar && !this.get$isOperator()) {
     return this.invokeOnVar(context, node, target, args);
   }
-  if (this.members.get$length() == 1) {
-    return this.members.$index(0).invoke$5(context, node, target, args, isDynamic);
+  if (this.members.get$length() == (1)) {
+    return this.members.$index((0)).invoke$5(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
-  if ($eq(targets.get$length(), 1)) {
-    return targets.$index(0).invoke$5(context, node, target, args, isDynamic);
+  if ($eq(targets.get$length(), (1))) {
+    return targets.$index((0)).invoke$5(context, node, target, args, isDynamic);
   }
   var returnValue = null;
   for (var $$i = targets.iterator$0(); $$i.hasNext$0(); ) {
     var member = $$i.next$0();
     var res = member.invoke$4$isDynamic(context, node, target, args, true);
     returnValue = this._tryUnion(returnValue, res, node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, "method");
   }
-  if (returnValue.code == null) {
+  if (returnValue.get$code() == null) {
     if (this.name == ":call") {
       return target._varCall(context, node, args);
     }
     else if (this.get$isOperator()) {
       return this.invokeSpecial(target, args, returnValue.get$type());
     }
     else {
       return this.invokeOnVar(context, node, target, args);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invokeSpecial = function(target, args, returnType) {
   var argsString = args.getCode();
   if (this.name == ":index" || this.name == ":setindex") {
-    return new Value(returnType, ("" + target.code + "." + this.jsname + "(" + argsString + ")"), target.span, true);
+    return new Value(returnType, ("" + target.get$code() + "." + this.jsname + "(" + argsString + ")"), target.span, true);
   }
   else {
-    if (argsString.get$length() > 0) argsString = (", " + argsString);
+    if (argsString.get$length() > (0)) argsString = (", " + argsString);
     $globals.world.gen.corejs.useOperator(this.name);
-    return new Value(returnType, ("" + this.jsname + "(" + target.code + argsString + ")"), target.span, true);
+    return new Value(returnType, ("" + this.jsname + "(" + target.get$code() + argsString + ")"), target.span, true);
   }
 }
 MemberSet.prototype.invokeOnVar = function(context, node, target, args) {
   var member = this.getVarMember(context, node, args);
   return member.invoke$4(context, node, target, args);
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
   var type = Type.union(x.get$type(), y.get$type());
-  if (x.code == y.code) {
+  if (x.get$code() == y.get$code()) {
     if ($eq(type, x.get$type())) {
       return x;
     }
     else if (x.get$isConst() || y.get$isConst()) {
       $globals.world.internalError("unexpected: union of const values ");
     }
     else {
-      var ret = new Value(type, x.code, node.span, true);
+      var ret = new Value(type, x.get$code(), node.span, true);
       ret.set$isSuper(x.isSuper && y.isSuper);
       ret.set$needsTemp(x.needsTemp || y.needsTemp);
       ret.set$isType(x.isType && y.isType);
       return ret;
     }
   }
   else {
     return new Value(type, null, node.span, true);
   }
 }
@@ skipping 81 matching lines @@
 Token.prototype.get$kind = function() { return this.kind; };
 Token.prototype.get$end = function() { return this.end; };
 Token.prototype.get$start = function() { return this.start; };
 Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($ne(kindText, actualText)) {
-    if (actualText.get$length() > 10) {
-      actualText = actualText.substring$2(0, 8) + "...";
+    if (actualText.get$length() > (10)) {
+      actualText = actualText.substring$2((0), (8)) + "...";
     }
     return ("" + kindText + "(" + actualText + ")");
   }
   else {
     return kindText;
   }
 }
 Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
@@ skipping 29 matching lines @@
   // 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];
-    var index = 0;
+    var starts = [(0)];
+    var index = (0);
     while (index < this.get$text().length) {
-      index = this.get$text().indexOf("\n", index) + 1;
-      if (index <= 0) break;
+      index = this.get$text().indexOf("\n", index) + (1);
+      if (index <= (0)) break;
       starts.add$1(index);
     }
-    starts.add$1(this.get$text().length + 1);
+    starts.add$1(this.get$text().length + (1));
     this._lineStarts = starts;
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
-  for (var i = 0;
+  for (var i = (0);
    i < starts.get$length(); i++) {
-    if (starts.$index(i) > position) return i - 1;
+    if (starts.$index(i) > position) return i - (1);
   }
   $globals.world.internalError("bad position");
 }
 SourceFile.prototype.getColumn = function(line, position) {
   return position - this.get$lineStarts().$index(line);
 }
 SourceFile.prototype.getLocationMessage = function(message, start, end, includeText) {
   var line = this.getLine(start);
   var column = this.getColumn(line, start);
-  var buf = new StringBufferImpl(("" + this.filename + ":" + (line + 1) + ":" + (column + 1) + ": " + message));
+  var buf = new StringBufferImpl(("" + this.filename + ":" + (line + (1)) + ":" + (column + (1)) + ": " + message));
   if (includeText) {
     buf.add$1("\n");
     var textLine;
-    if ((line + 2) < this._lineStarts.get$length()) {
-      textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index(line + 1));
+    if ((line + (2)) < this._lineStarts.get$length()) {
+      textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index(line + (1)));
     }
     else {
       textLine = this.get$text().substring(this._lineStarts.$index(line)) + "\n";
     }
     var toColumn = Math.min(column + (end - start), textLine.get$length());
     if ($globals.options.useColors) {
-      buf.add$1(textLine.substring$2(0, column));
+      buf.add$1(textLine.substring$2((0), column));
       buf.add$1($globals._RED_COLOR);
       buf.add$1(textLine.substring$2(column, toColumn));
       buf.add$1($globals._NO_COLOR);
       buf.add$1(textLine.substring$1(toColumn));
     }
     else {
       buf.add$1(textLine);
     }
-    var i = 0;
+    var i = (0);
     for (; i < column; i++) {
       buf.add$1(" ");
     }
     if ($globals.options.useColors) buf.add$1($globals._RED_COLOR);
     for (; i < toColumn; i++) {
       buf.add$1("^");
     }
     if ($globals.options.useColors) buf.add$1($globals._NO_COLOR);
   }
   return buf.toString$0();
@@ skipping 21 matching lines @@
 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);
 }
 SourceSpan.prototype.get$locationText = function() {
   var line = this.file.getLine(this.start);
   var column = this.file.getColumn(line, this.start);
-  return ("" + this.file.filename + ":" + (line + 1) + ":" + (column + 1));
+  return ("" + this.file.filename + ":" + (line + (1)) + ":" + (column + (1)));
 }
 SourceSpan.prototype.compareTo = function(other) {
   if ($eq(this.file, other.file)) {
     var d = this.start - other.start;
-    return d == 0 ? (this.end - other.end) : d;
+    return d == (0) ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 SourceSpan.prototype.compareTo$1 = SourceSpan.prototype.compareTo;
 SourceSpan.prototype.end$0 = function() {
   return this.end.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;
+  this.depth = (-1);
   // Initializers done
 }
 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);
+  return ((c >= (97) && c <= (122)) || (c >= (65) && c <= (90)) || c == (95));
 }
 TokenizerHelpers.isDigit = function(c) {
-  return (c >= 48 && c <= 57);
+  return (c >= (48) && c <= (57));
 }
 TokenizerHelpers.isIdentifierPart = function(c) {
-  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == 36);
+  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c) || c == (36));
 }
 TokenizerHelpers.isInterpIdentifierPart = function(c) {
   return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
 }
 // ********** Code for TokenizerBase **************
 $inherits(TokenizerBase, TokenizerHelpers);
 function TokenizerBase(_source, _skipWhitespace, index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._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;
+    return (0);
   }
 }
 TokenizerBase.prototype._peekChar = function() {
   if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index);
   }
   else {
-    return 0;
+    return (0);
   }
 }
 TokenizerBase.prototype._maybeEatChar = function(ch) {
   if (this._lang_index < this._text.length) {
     if (this._text.charCodeAt(this._lang_index) == ch) {
       this._lang_index++;
       return true;
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
   return new Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function(message) {
-  return new ErrorToken(65/*TokenKind.ERROR*/, this._source, this._startIndex, this._lang_index, message);
+  return new ErrorToken((65), this._source, this._startIndex, this._lang_index, message);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
   this._lang_index--;
   while (this._lang_index < this._text.length) {
     var ch = this._text.charCodeAt(this._lang_index++);
-    if (ch == 32 || ch == 9 || ch == 13) {
+    if (ch == (32) || ch == (9) || ch == (13)) {
     }
-    else if (ch == 10) {
+    else if (ch == (10)) {
       if (!this._skipWhitespace) {
-        return this._finishToken(63/*TokenKind.WHITESPACE*/);
+        return this._finishToken((63));
       }
     }
     else {
       this._lang_index--;
       if (this._skipWhitespace) {
         return this.next();
       }
       else {
-        return this._finishToken(63/*TokenKind.WHITESPACE*/);
+        return this._finishToken((63));
       }
     }
   }
-  return this._finishToken(1/*TokenKind.END_OF_FILE*/);
+  return this._finishToken((1));
 }
 TokenizerBase.prototype.finishHashBang = function() {
   while (true) {
     var ch = this._nextChar();
-    if (ch == 0 || ch == 10 || ch == 13) {
-      return this._finishToken(13/*TokenKind.HASHBANG*/);
+    if (ch == (0) || ch == (10) || ch == (13)) {
+      return this._finishToken((13));
     }
   }
 }
 TokenizerBase.prototype.finishSingleLineComment = function() {
   while (true) {
     var ch = this._nextChar();
-    if (ch == 0 || ch == 10 || ch == 13) {
+    if (ch == (0) || ch == (10) || ch == (13)) {
       if (this._skipWhitespace) {
         return this.next();
       }
       else {
-        return this._finishToken(64/*TokenKind.COMMENT*/);
+        return this._finishToken((64));
       }
     }
   }
 }
 TokenizerBase.prototype.finishMultiLineComment = function() {
-  var nesting = 1;
+  var nesting = (1);
   do {
     var ch = this._nextChar();
-    if (ch == 0) {
+    if (ch == (0)) {
       return this._errorToken();
     }
-    else if (ch == 42) {
-      if (this._maybeEatChar(47)) {
+    else if (ch == (42)) {
+      if (this._maybeEatChar((47))) {
         nesting--;
       }
     }
-    else if (ch == 47) {
-      if (this._maybeEatChar(42)) {
+    else if (ch == (47)) {
+      if (this._maybeEatChar((42))) {
         nesting++;
       }
     }
   }
-  while (nesting > 0)
+  while (nesting > (0))
   if (this._skipWhitespace) {
     return this.next();
   }
   else {
-    return this._finishToken(64/*TokenKind.COMMENT*/);
+    return this._finishToken((64));
   }
 }
 TokenizerBase.prototype.eatDigits = function() {
   while (this._lang_index < this._text.length) {
     if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._lang_index))) {
       this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase._hexDigit = function(c) {
-  if (c >= 48 && c <= 57) {
-    return c - 48;
+  if (c >= (48) && c <= (57)) {
+    return c - (48);
   }
-  else if (c >= 97 && c <= 102) {
-    return c - 87;
+  else if (c >= (97) && c <= (102)) {
+    return c - (87);
   }
-  else if (c >= 65 && c <= 70) {
-    return c - 55;
+  else if (c >= (65) && c <= (70)) {
+    return c - (55);
   }
   else {
-    return -1;
+    return (-1);
   }
 }
 TokenizerBase.prototype.readHex = function(hexLength) {
   var maxIndex;
   if (hexLength == null) {
-    maxIndex = this._text.length - 1;
+    maxIndex = this._text.length - (1);
   }
   else {
     maxIndex = this._lang_index + hexLength;
-    if (maxIndex >= this._text.length) return -1;
+    if (maxIndex >= this._text.length) return (-1);
   }
-  var result = 0;
+  var result = (0);
   while (this._lang_index < maxIndex) {
     var digit = TokenizerBase._hexDigit(this._text.charCodeAt(this._lang_index));
-    if (digit == -1) {
+    if (digit == (-1)) {
       if (hexLength == null) {
         return result;
       }
       else {
-        return -1;
+        return (-1);
       }
     }
     TokenizerBase._hexDigit(this._text.charCodeAt(this._lang_index));
-    result = (result * 16) + digit;
+    result = (result * (16)) + digit;
     this._lang_index++;
   }
   return result;
 }
 TokenizerBase.prototype.finishHex = function() {
   var value = this.readHex();
-  return new LiteralToken(61/*TokenKind.HEX_INTEGER*/, this._source, this._startIndex, this._lang_index, value);
+  return new LiteralToken((61), this._source, this._startIndex, this._lang_index, value);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
-  if (this._peekChar() == 46) {
+  if (this._peekChar() == (46)) {
     this._nextChar();
     if (TokenizerHelpers.isDigit(this._peekChar())) {
       this.eatDigits();
-      return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
+      return this.finishNumberExtra((62));
     }
     else {
       this._lang_index--;
     }
   }
-  return this.finishNumberExtra(60/*TokenKind.INTEGER*/);
+  return this.finishNumberExtra((60));
 }
 TokenizerBase.prototype.finishNumberExtra = function(kind) {
-  if (this._maybeEatChar(101) || this._maybeEatChar(69)) {
-    kind = 62/*TokenKind.DOUBLE*/;
-    this._maybeEatChar(45);
-    this._maybeEatChar(43);
+  if (this._maybeEatChar((101)) || this._maybeEatChar((69))) {
+    kind = (62);
+    this._maybeEatChar((45));
+    this._maybeEatChar((43));
     this.eatDigits();
   }
-  if (this._peekChar() != 0 && TokenizerHelpers.isIdentifierStart(this._peekChar())) {
+  if (this._peekChar() != (0) && TokenizerHelpers.isIdentifierStart(this._peekChar())) {
     this._nextChar();
     return this._errorToken("illegal character in number");
   }
   return this._finishToken(kind);
 }
 TokenizerBase.prototype._makeStringToken = function(buf, isPart) {
   var s = Strings.String$fromCharCodes$factory(buf);
-  var kind = isPart ? 59/*TokenKind.STRING_PART*/ : 58/*TokenKind.STRING*/;
+  var kind = isPart ? (59) : (58);
   return new LiteralToken(kind, this._source, this._startIndex, this._lang_index, s);
 }
 TokenizerBase.prototype._makeRawStringToken = function(isMultiline) {
   var s;
   if (isMultiline) {
-    if (this._source.get$text()[this._startIndex + 4] == "\n") {
-      s = this._source.get$text().substring(this._startIndex + 5, this._lang_index - 3);
+    if (this._source.get$text()[this._startIndex + (4)] == "\n") {
+      s = this._source.get$text().substring(this._startIndex + (5), this._lang_index - (3));
     }
     else {
-      s = this._source.get$text().substring(this._startIndex + 4, this._lang_index - 3);
+      s = this._source.get$text().substring(this._startIndex + (4), this._lang_index - (3));
     }
   }
   else {
-    s = this._source.get$text().substring(this._startIndex + 2, this._lang_index - 1);
+    s = this._source.get$text().substring(this._startIndex + (2), this._lang_index - (1));
   }
-  return new LiteralToken(58/*TokenKind.STRING*/, this._source, this._startIndex, this._lang_index, s);
+  return new LiteralToken((58), this._source, this._startIndex, this._lang_index, s);
 }
 TokenizerBase.prototype.finishMultilineString = function(quote) {
   var buf = new Array();
   while (true) {
     var ch = this._nextChar();
-    if (ch == 0) {
+    if (ch == (0)) {
       return this._errorToken();
     }
     else if (ch == quote) {
       if (this._maybeEatChar(quote)) {
         if (this._maybeEatChar(quote)) {
           return this._makeStringToken(buf, false);
         }
         buf.add$1(quote);
       }
       buf.add$1(quote);
     }
-    else if (ch == 36) {
+    else if (ch == (36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, true);
       return this._makeStringToken(buf, true);
     }
-    else if (ch == 92) {
+    else if (ch == (92)) {
       var escapeVal = this.readEscapeSequence();
-      if ($eq(escapeVal, -1)) {
+      if ($eq(escapeVal, (-1))) {
         return this._errorToken("invalid hex escape sequence");
       }
       else {
         buf.add$1(escapeVal);
       }
     }
     else {
       buf.add$1(ch);
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if (this._interpStack != null) {
-    if (this._interpStack.depth == -1) {
-      this._interpStack.depth = 1;
+    if (this._interpStack.depth == (-1)) {
+      this._interpStack.depth = (1);
     }
     else {
-      ($0 = this._interpStack).depth = $0.depth + 1;
+      ($0 = this._interpStack).depth = $0.depth + (1);
     }
   }
-  return this._finishToken(6/*TokenKind.LBRACE*/);
+  return this._finishToken((6));
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
   if (this._interpStack != null) {
-    ($0 = this._interpStack).depth = $0.depth - 1;
+    ($0 = this._interpStack).depth = $0.depth - (1);
   }
-  return this._finishToken(7/*TokenKind.RBRACE*/);
+  return this._finishToken((7));
 }
 TokenizerBase.prototype.finishString = function(quote) {
   if (this._maybeEatChar(quote)) {
     if (this._maybeEatChar(quote)) {
-      this._maybeEatChar(10);
+      this._maybeEatChar((10));
       return this.finishMultilineString(quote);
     }
     else {
       return this._makeStringToken(new Array(), false);
     }
   }
   return this.finishStringBody(quote);
 }
 TokenizerBase.prototype.finishRawString = function(quote) {
   if (this._maybeEatChar(quote)) {
     if (this._maybeEatChar(quote)) {
       return this.finishMultilineRawString(quote);
     }
     else {
       return this._makeStringToken(new Array(), false);
     }
   }
   while (true) {
     var ch = this._nextChar();
     if (ch == quote) {
       return this._makeRawStringToken(false);
     }
-    else if (ch == 0) {
+    else if (ch == (0)) {
       return this._errorToken();
     }
   }
 }
 TokenizerBase.prototype.finishMultilineRawString = function(quote) {
   while (true) {
     var ch = this._nextChar();
-    if (ch == 0) {
+    if (ch == (0)) {
       return this._errorToken();
     }
     else if (ch == quote && this._maybeEatChar(quote) && this._maybeEatChar(quote)) {
       return this._makeRawStringToken(true);
     }
   }
 }
 TokenizerBase.prototype.finishStringBody = function(quote) {
   var buf = new Array();
   while (true) {
     var ch = this._nextChar();
     if (ch == quote) {
       return this._makeStringToken(buf, false);
     }
-    else if (ch == 36) {
+    else if (ch == (36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, false);
       return this._makeStringToken(buf, true);
     }
-    else if (ch == 0) {
+    else if (ch == (0)) {
       return this._errorToken();
     }
-    else if (ch == 92) {
+    else if (ch == (92)) {
       var escapeVal = this.readEscapeSequence();
-      if ($eq(escapeVal, -1)) {
+      if ($eq(escapeVal, (-1))) {
         return this._errorToken("invalid hex escape sequence");
       }
       else {
         buf.add$1(escapeVal);
       }
     }
     else {
       buf.add$1(ch);
     }
   }
 }
 TokenizerBase.prototype.readEscapeSequence = function() {
   var ch = this._nextChar();
   var hexValue;
   switch (ch) {
-    case 110:
+    case (110):
 
-      return 10;
+      return (10);
 
-    case 114:
+    case (114):
 
-      return 13;
+      return (13);
 
-    case 102:
+    case (102):
 
-      return 12;
+      return (12);
 
-    case 98:
+    case (98):
 
-      return 8;
+      return (8);
 
-    case 116:
+    case (116):
 
-      return 9;
+      return (9);
 
-    case 118:
+    case (118):
 
-      return 11;
+      return (11);
 
-    case 120:
+    case (120):
 
-      hexValue = this.readHex(2);
+      hexValue = this.readHex((2));
       break;
 
-    case 117:
+    case (117):
 
-      if (this._maybeEatChar(123)) {
+      if (this._maybeEatChar((123))) {
         hexValue = this.readHex();
-        if (!this._maybeEatChar(125)) {
-          return -1;
+        if (!this._maybeEatChar((125))) {
+          return (-1);
         }
         else {
           break;
         }
       }
       else {
-        hexValue = this.readHex(4);
+        hexValue = this.readHex((4));
         break;
       }
 
     default:
 
       return ch;
 
   }
-  if (hexValue == -1) return -1;
-  if (hexValue < 55296 || hexValue > 57343 && hexValue <= 65535) {
+  if (hexValue == (-1)) return (-1);
+  if (hexValue < (55296) || hexValue > (57343) && hexValue <= (65535)) {
     return hexValue;
   }
-  else if (hexValue <= 1114111) {
+  else if (hexValue <= (1114111)) {
     $globals.world.fatal("unicode values greater than 2 bytes not implemented yet");
-    return -1;
+    return (-1);
   }
   else {
-    return -1;
+    return (-1);
   }
 }
 TokenizerBase.prototype.finishDot = function() {
   if (TokenizerHelpers.isDigit(this._peekChar())) {
     this.eatDigits();
-    return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
+    return this.finishNumberExtra((62));
   }
   else {
-    return this._finishToken(14/*TokenKind.DOT*/);
+    return this._finishToken((14));
   }
 }
 TokenizerBase.prototype.finishIdentifier = function(ch) {
-  if (this._interpStack != null && this._interpStack.depth == -1) {
-    this._interpStack.depth = 0;
-    if (ch == 36) {
+  if (this._interpStack != null && this._interpStack.depth == (-1)) {
+    this._interpStack.depth = (0);
+    if (ch == (36)) {
       return this._errorToken("illegal character after $ in string interpolation");
     }
     while (this._lang_index < this._text.length) {
       if (!TokenizerHelpers.isInterpIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
         this._lang_index--;
         break;
       }
     }
   }
   else {
     while (this._lang_index < this._text.length) {
       if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
         this._lang_index--;
         break;
       }
     }
   }
   var kind = this.getIdentifierKind();
-  if (kind == 70/*TokenKind.IDENTIFIER*/) {
-    return this._finishToken(70/*TokenKind.IDENTIFIER*/);
+  if (kind == (70)) {
+    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) {
+  if (this._interpStack != null && this._interpStack.depth == (0)) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
     if (istack.get$isMultiline()) {
       return this.finishMultilineString(istack.get$quote());
     }
     else {
       return this.finishStringBody(istack.get$quote());
     }
   }
   var ch;
   ch = this._nextChar();
   switch (ch) {
-    case 0:
+    case (0):
 
-      return this._finishToken(1/*TokenKind.END_OF_FILE*/);
+      return this._finishToken((1));
 
-    case 32:
-    case 9:
-    case 10:
-    case 13:
+    case (32):
+    case (9):
+    case (10):
+    case (13):
 
       return this.finishWhitespace();
 
-    case 33:
+    case (33):
 
-      if (this._maybeEatChar(61)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(51/*TokenKind.NE_STRICT*/);
+      if (this._maybeEatChar((61))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((51));
         }
         else {
-          return this._finishToken(49/*TokenKind.NE*/);
+          return this._finishToken((49));
         }
       }
       else {
-        return this._finishToken(19/*TokenKind.NOT*/);
+        return this._finishToken((19));
       }
 
-    case 34:
+    case (34):
 
-      return this.finishString(34);
+      return this.finishString((34));
 
-    case 35:
+    case (35):
 
-      if (this._maybeEatChar(33)) {
+      if (this._maybeEatChar((33))) {
         return this.finishHashBang();
       }
       else {
-        return this._finishToken(12/*TokenKind.HASH*/);
+        return this._finishToken((12));
       }
 
-    case 36:
+    case (36):
 
-      if (this._maybeEatChar(34)) {
-        return this.finishString(34);
+      if (this._maybeEatChar((34))) {
+        return this.finishString((34));
       }
-      else if (this._maybeEatChar(39)) {
-        return this.finishString(39);
+      else if (this._maybeEatChar((39))) {
+        return this.finishString((39));
       }
       else {
-        return this.finishIdentifier(36);
+        return this.finishIdentifier((36));
       }
 
-    case 37:
+    case (37):
 
-      if (this._maybeEatChar(61)) {
-        return this._finishToken(32/*TokenKind.ASSIGN_MOD*/);
+      if (this._maybeEatChar((61))) {
+        return this._finishToken((32));
       }
       else {
-        return this._finishToken(47/*TokenKind.MOD*/);
+        return this._finishToken((47));
       }
 
-    case 38:
+    case (38):
 
-      if (this._maybeEatChar(38)) {
-        return this._finishToken(35/*TokenKind.AND*/);
+      if (this._maybeEatChar((38))) {
+        return this._finishToken((35));
       }
-      else if (this._maybeEatChar(61)) {
-        return this._finishToken(23/*TokenKind.ASSIGN_AND*/);
+      else if (this._maybeEatChar((61))) {
+        return this._finishToken((23));
       }
       else {
-        return this._finishToken(38/*TokenKind.BIT_AND*/);
+        return this._finishToken((38));
       }
 
-    case 39:
+    case (39):
 
-      return this.finishString(39);
+      return this.finishString((39));
 
-    case 40:
+    case (40):
 
-      return this._finishToken(2/*TokenKind.LPAREN*/);
+      return this._finishToken((2));
 
-    case 41:
+    case (41):
 
-      return this._finishToken(3/*TokenKind.RPAREN*/);
+      return this._finishToken((3));
 
-    case 42:
+    case (42):
 
-      if (this._maybeEatChar(61)) {
-        return this._finishToken(29/*TokenKind.ASSIGN_MUL*/);
+      if (this._maybeEatChar((61))) {
+        return this._finishToken((29));
       }
       else {
-        return this._finishToken(44/*TokenKind.MUL*/);
+        return this._finishToken((44));
       }
 
-    case 43:
+    case (43):
 
-      if (this._maybeEatChar(43)) {
-        return this._finishToken(16/*TokenKind.INCR*/);
+      if (this._maybeEatChar((43))) {
+        return this._finishToken((16));
       }
-      else if (this._maybeEatChar(61)) {
-        return this._finishToken(27/*TokenKind.ASSIGN_ADD*/);
+      else if (this._maybeEatChar((61))) {
+        return this._finishToken((27));
       }
       else {
-        return this._finishToken(42/*TokenKind.ADD*/);
+        return this._finishToken((42));
       }
 
-    case 44:
+    case (44):
 
-      return this._finishToken(11/*TokenKind.COMMA*/);
+      return this._finishToken((11));
 
-    case 45:
+    case (45):
 
-      if (this._maybeEatChar(45)) {
-        return this._finishToken(17/*TokenKind.DECR*/);
+      if (this._maybeEatChar((45))) {
+        return this._finishToken((17));
       }
-      else if (this._maybeEatChar(61)) {
-        return this._finishToken(28/*TokenKind.ASSIGN_SUB*/);
+      else if (this._maybeEatChar((61))) {
+        return this._finishToken((28));
       }
       else {
-        return this._finishToken(43/*TokenKind.SUB*/);
+        return this._finishToken((43));
       }
 
-    case 46:
+    case (46):
 
-      if (this._maybeEatChar(46)) {
-        if (this._maybeEatChar(46)) {
-          return this._finishToken(15/*TokenKind.ELLIPSIS*/);
+      if (this._maybeEatChar((46))) {
+        if (this._maybeEatChar((46))) {
+          return this._finishToken((15));
         }
         else {
           return this._errorToken();
         }
       }
       else {
         return this.finishDot();
       }
 
-    case 47:
+    case (47):
 
-      if (this._maybeEatChar(42)) {
+      if (this._maybeEatChar((42))) {
         return this.finishMultiLineComment();
       }
-      else if (this._maybeEatChar(47)) {
+      else if (this._maybeEatChar((47))) {
         return this.finishSingleLineComment();
       }
-      else if (this._maybeEatChar(61)) {
-        return this._finishToken(30/*TokenKind.ASSIGN_DIV*/);
+      else if (this._maybeEatChar((61))) {
+        return this._finishToken((30));
       }
       else {
-        return this._finishToken(45/*TokenKind.DIV*/);
+        return this._finishToken((45));
       }
 
-    case 48:
+    case (48):
 
-      if (this._maybeEatChar(88)) {
+      if (this._maybeEatChar((88))) {
         return this.finishHex();
       }
-      else if (this._maybeEatChar(120)) {
+      else if (this._maybeEatChar((120))) {
         return this.finishHex();
       }
       else {
         return this.finishNumber();
       }
 
-    case 58:
+    case (58):
 
-      return this._finishToken(8/*TokenKind.COLON*/);
+      return this._finishToken((8));
 
-    case 59:
+    case (59):
 
-      return this._finishToken(10/*TokenKind.SEMICOLON*/);
+      return this._finishToken((10));
 
-    case 60:
+    case (60):
 
-      if (this._maybeEatChar(60)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(24/*TokenKind.ASSIGN_SHL*/);
+      if (this._maybeEatChar((60))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((24));
         }
         else {
-          return this._finishToken(39/*TokenKind.SHL*/);
+          return this._finishToken((39));
         }
       }
-      else if (this._maybeEatChar(61)) {
-        return this._finishToken(54/*TokenKind.LTE*/);
+      else if (this._maybeEatChar((61))) {
+        return this._finishToken((54));
       }
       else {
-        return this._finishToken(52/*TokenKind.LT*/);
+        return this._finishToken((52));
       }
 
-    case 61:
+    case (61):
 
-      if (this._maybeEatChar(61)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(50/*TokenKind.EQ_STRICT*/);
+      if (this._maybeEatChar((61))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((50));
         }
         else {
-          return this._finishToken(48/*TokenKind.EQ*/);
+          return this._finishToken((48));
         }
       }
-      else if (this._maybeEatChar(62)) {
-        return this._finishToken(9/*TokenKind.ARROW*/);
+      else if (this._maybeEatChar((62))) {
+        return this._finishToken((9));
       }
       else {
-        return this._finishToken(20/*TokenKind.ASSIGN*/);
+        return this._finishToken((20));
       }
 
-    case 62:
+    case (62):
 
-      if (this._maybeEatChar(61)) {
-        return this._finishToken(55/*TokenKind.GTE*/);
+      if (this._maybeEatChar((61))) {
+        return this._finishToken((55));
       }
-      else if (this._maybeEatChar(62)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(25/*TokenKind.ASSIGN_SAR*/);
+      else if (this._maybeEatChar((62))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((25));
         }
-        else if (this._maybeEatChar(62)) {
-          if (this._maybeEatChar(61)) {
-            return this._finishToken(26/*TokenKind.ASSIGN_SHR*/);
+        else if (this._maybeEatChar((62))) {
+          if (this._maybeEatChar((61))) {
+            return this._finishToken((26));
           }
           else {
-            return this._finishToken(41/*TokenKind.SHR*/);
+            return this._finishToken((41));
           }
         }
         else {
-          return this._finishToken(40/*TokenKind.SAR*/);
+          return this._finishToken((40));
         }
       }
       else {
-        return this._finishToken(53/*TokenKind.GT*/);
+        return this._finishToken((53));
       }
 
-    case 63:
+    case (63):
 
-      return this._finishToken(33/*TokenKind.CONDITIONAL*/);
+      return this._finishToken((33));
 
-    case 64:
+    case (64):
 
-      if (this._maybeEatChar(34)) {
-        return this.finishRawString(34);
+      if (this._maybeEatChar((34))) {
+        return this.finishRawString((34));
       }
-      else if (this._maybeEatChar(39)) {
-        return this.finishRawString(39);
+      else if (this._maybeEatChar((39))) {
+        return this.finishRawString((39));
       }
       else {
         return this._errorToken();
       }
 
-    case 91:
+    case (91):
 
-      if (this._maybeEatChar(93)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(57/*TokenKind.SETINDEX*/);
+      if (this._maybeEatChar((93))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((57));
         }
         else {
-          return this._finishToken(56/*TokenKind.INDEX*/);
+          return this._finishToken((56));
         }
       }
       else {
-        return this._finishToken(4/*TokenKind.LBRACK*/);
+        return this._finishToken((4));
       }
 
-    case 93:
+    case (93):
 
-      return this._finishToken(5/*TokenKind.RBRACK*/);
+      return this._finishToken((5));
 
-    case 94:
+    case (94):
 
-      if (this._maybeEatChar(61)) {
-        return this._finishToken(22/*TokenKind.ASSIGN_XOR*/);
+      if (this._maybeEatChar((61))) {
+        return this._finishToken((22));
       }
       else {
-        return this._finishToken(37/*TokenKind.BIT_XOR*/);
+        return this._finishToken((37));
       }
 
-    case 123:
+    case (123):
 
       return this._finishOpenBrace();
 
-    case 124:
+    case (124):
 
-      if (this._maybeEatChar(61)) {
-        return this._finishToken(21/*TokenKind.ASSIGN_OR*/);
+      if (this._maybeEatChar((61))) {
+        return this._finishToken((21));
       }
-      else if (this._maybeEatChar(124)) {
-        return this._finishToken(34/*TokenKind.OR*/);
+      else if (this._maybeEatChar((124))) {
+        return this._finishToken((34));
       }
       else {
-        return this._finishToken(36/*TokenKind.BIT_OR*/);
+        return this._finishToken((36));
       }
 
-    case 125:
+    case (125):
 
       return this._finishCloseBrace();
 
-    case 126:
+    case (126):
 
-      if (this._maybeEatChar(47)) {
-        if (this._maybeEatChar(61)) {
-          return this._finishToken(31/*TokenKind.ASSIGN_TRUNCDIV*/);
+      if (this._maybeEatChar((47))) {
+        if (this._maybeEatChar((61))) {
+          return this._finishToken((31));
         }
         else {
-          return this._finishToken(46/*TokenKind.TRUNCDIV*/);
+          return this._finishToken((46));
         }
       }
       else {
-        return this._finishToken(18/*TokenKind.BIT_NOT*/);
+        return this._finishToken((18));
       }
 
     default:
 
       if (TokenizerHelpers.isIdentifierStart(ch)) {
         return this.finishIdentifier(ch);
       }
       else if (TokenizerHelpers.isDigit(ch)) {
         return this.finishNumber();
       }
       else {
         return this._errorToken();
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
   var ch;
   switch (this._lang_index - i0) {
-    case 2:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 100) {
-        if (this._text.charCodeAt(i0 + 1) == 111) return 94/*TokenKind.DO*/;
-      }
-      else if (ch == 105) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 102) {
-          return 101/*TokenKind.IF*/;
-        }
-        else if (ch == 110) {
-          return 102/*TokenKind.IN*/;
-        }
-        else if (ch == 115) {
-          return 103/*TokenKind.IS*/;
-        }
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 3:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 102) {
-        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114) return 100/*TokenKind.FOR*/;
-      }
-      else if (ch == 103) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 74/*TokenKind.GET*/;
-      }
-      else if (ch == 110) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119) return 104/*TokenKind.NEW*/;
-      }
-      else if (ch == 115) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 82/*TokenKind.SET*/;
-      }
-      else if (ch == 116) {
-        if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121) return 112/*TokenKind.TRY*/;
-      }
-      else if (ch == 118) {
-        if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114) return 113/*TokenKind.VAR*/;
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 4:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 99) {
-        if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 88/*TokenKind.CASE*/;
-      }
-      else if (ch == 101) {
-        if (this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 95/*TokenKind.ELSE*/;
-      }
-      else if (ch == 110) {
-        if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 108) return 105/*TokenKind.NULL*/;
-      }
-      else if (ch == 116) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 104) {
-          if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115) return 109/*TokenKind.THIS*/;
-        }
-        else if (ch == 114) {
-          if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101) return 111/*TokenKind.TRUE*/;
-        }
-      }
-      else if (ch == 118) {
-        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 100) return 114/*TokenKind.VOID*/;
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 5:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 97) {
-        if (this._text.charCodeAt(i0 + 1) == 119 && this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 116) return 86/*TokenKind.AWAIT*/;
-      }
-      else if (ch == 98) {
-        if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107) return 87/*TokenKind.BREAK*/;
-      }
-      else if (ch == 99) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 97) {
-          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99 && this._text.charCodeAt(i0 + 4) == 104) return 89/*TokenKind.CATCH*/;
-        }
-        else if (ch == 108) {
-          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115) return 90/*TokenKind.CLASS*/;
-        }
-        else if (ch == 111) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116) return 91/*TokenKind.CONST*/;
-        }
-      }
-      else if (ch == 102) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 97) {
-          if (this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 101) return 97/*TokenKind.FALSE*/;
-        }
-        else if (ch == 105) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108) return 98/*TokenKind.FINAL*/;
-        }
-      }
-      else if (ch == 115) {
-        if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114) return 107/*TokenKind.SUPER*/;
-      }
-      else if (ch == 116) {
-        if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119) return 110/*TokenKind.THROW*/;
-      }
-      else if (ch == 119) {
-        if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101) return 115/*TokenKind.WHILE*/;
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 6:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 97) {
-        if (this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 72/*TokenKind.ASSERT*/;
-      }
-      else if (ch == 105) {
-        if (this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 76/*TokenKind.IMPORT*/;
-      }
-      else if (ch == 110) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 97) {
-          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 79/*TokenKind.NATIVE*/;
-        }
-        else if (ch == 101) {
-          if (this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 80/*TokenKind.NEGATE*/;
-        }
-      }
-      else if (ch == 114) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110) return 106/*TokenKind.RETURN*/;
-      }
-      else if (ch == 115) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 111) {
-          if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101) return 83/*TokenKind.SOURCE*/;
-        }
-        else if (ch == 116) {
-          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99) return 84/*TokenKind.STATIC*/;
-        }
-        else if (ch == 119) {
-          if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104) return 108/*TokenKind.SWITCH*/;
-        }
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 7:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 100) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116) return 93/*TokenKind.DEFAULT*/;
-      }
-      else if (ch == 101) {
-        if (this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115) return 96/*TokenKind.EXTENDS*/;
-      }
-      else if (ch == 102) {
-        ch = this._text.charCodeAt(i0 + 1);
-        if (ch == 97) {
-          if (this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 73/*TokenKind.FACTORY*/;
-        }
-        else if (ch == 105) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121) return 99/*TokenKind.FINALLY*/;
-        }
-      }
-      else if (ch == 108) {
-        if (this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 78/*TokenKind.LIBRARY*/;
-      }
-      else if (ch == 116) {
-        if (this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102) return 85/*TokenKind.TYPEDEF*/;
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 8:
-
-      ch = this._text.charCodeAt(i0);
-      if (ch == 97) {
-        if (this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116) return 71/*TokenKind.ABSTRACT*/;
-      }
-      else if (ch == 99) {
-        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101) return 92/*TokenKind.CONTINUE*/;
-      }
-      else if (ch == 111) {
-        if (this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114) return 81/*TokenKind.OPERATOR*/;
-      }
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 9:
-
-      if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101) return 77/*TokenKind.INTERFACE*/;
-      return 70/*TokenKind.IDENTIFIER*/;
-
-    case 10:
-
-      if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 75/*TokenKind.IMPLEMENTS*/;
-      return 70/*TokenKind.IDENTIFIER*/;
+    case (2):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (100)) {
+        if (this._text.charCodeAt(i0 + (1)) == (111)) return (94);
+      }
+      else if (ch == (105)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (102)) {
+          return (101);
+        }
+        else if (ch == (110)) {
+          return (102);
+        }
+        else if (ch == (115)) {
+          return (103);
+        }
+      }
+      return (70);
+
+    case (3):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (102)) {
+        if (this._text.charCodeAt(i0 + (1)) == (111) && this._text.charCodeAt(i0 + (2)) == (114)) return (100);
+      }
+      else if (ch == (103)) {
+        if (this._text.charCodeAt(i0 + (1)) == (101) && this._text.charCodeAt(i0 + (2)) == (116)) return (74);
+      }
+      else if (ch == (110)) {
+        if (this._text.charCodeAt(i0 + (1)) == (101) && this._text.charCodeAt(i0 + (2)) == (119)) return (104);
+      }
+      else if (ch == (115)) {
+        if (this._text.charCodeAt(i0 + (1)) == (101) && this._text.charCodeAt(i0 + (2)) == (116)) return (82);
+      }
+      else if (ch == (116)) {
+        if (this._text.charCodeAt(i0 + (1)) == (114) && this._text.charCodeAt(i0 + (2)) == (121)) return (112);
+      }
+      else if (ch == (118)) {
+        if (this._text.charCodeAt(i0 + (1)) == (97) && this._text.charCodeAt(i0 + (2)) == (114)) return (113);
+      }
+      return (70);
+
+    case (4):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (99)) {
+        if (this._text.charCodeAt(i0 + (1)) == (97) && this._text.charCodeAt(i0 + (2)) == (115) && this._text.charCodeAt(i0 + (3)) == (101)) return (88);
+      }
+      else if (ch == (101)) {
+        if (this._text.charCodeAt(i0 + (1)) == (108) && this._text.charCodeAt(i0 + (2)) == (115) && this._text.charCodeAt(i0 + (3)) == (101)) return (95);
+      }
+      else if (ch == (110)) {
+        if (this._text.charCodeAt(i0 + (1)) == (117) && this._text.charCodeAt(i0 + (2)) == (108) && this._text.charCodeAt(i0 + (3)) == (108)) return (105);
+      }
+      else if (ch == (116)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (104)) {
+          if (this._text.charCodeAt(i0 + (2)) == (105) && this._text.charCodeAt(i0 + (3)) == (115)) return (109);
+        }
+        else if (ch == (114)) {
+          if (this._text.charCodeAt(i0 + (2)) == (117) && this._text.charCodeAt(i0 + (3)) == (101)) return (111);
+        }
+      }
+      else if (ch == (118)) {
+        if (this._text.charCodeAt(i0 + (1)) == (111) && this._text.charCodeAt(i0 + (2)) == (105) && this._text.charCodeAt(i0 + (3)) == (100)) return (114);
+      }
+      return (70);
+
+    case (5):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (97)) {
+        if (this._text.charCodeAt(i0 + (1)) == (119) && this._text.charCodeAt(i0 + (2)) == (97) && this._text.charCodeAt(i0 + (3)) == (105) && this._text.charCodeAt(i0 + (4)) == (116)) return (86);
+      }
+      else if (ch == (98)) {
+        if (this._text.charCodeAt(i0 + (1)) == (114) && this._text.charCodeAt(i0 + (2)) == (101) && this._text.charCodeAt(i0 + (3)) == (97) && this._text.charCodeAt(i0 + (4)) == (107)) return (87);
+      }
+      else if (ch == (99)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (97)) {
+          if (this._text.charCodeAt(i0 + (2)) == (116) && this._text.charCodeAt(i0 + (3)) == (99) && this._text.charCodeAt(i0 + (4)) == (104)) return (89);
+        }
+        else if (ch == (108)) {
+          if (this._text.charCodeAt(i0 + (2)) == (97) && this._text.charCodeAt(i0 + (3)) == (115) && this._text.charCodeAt(i0 + (4)) == (115)) return (90);
+        }
+        else if (ch == (111)) {
+          if (this._text.charCodeAt(i0 + (2)) == (110) && this._text.charCodeAt(i0 + (3)) == (115) && this._text.charCodeAt(i0 + (4)) == (116)) return (91);
+        }
+      }
+      else if (ch == (102)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (97)) {
+          if (this._text.charCodeAt(i0 + (2)) == (108) && this._text.charCodeAt(i0 + (3)) == (115) && this._text.charCodeAt(i0 + (4)) == (101)) return (97);
+        }
+        else if (ch == (105)) {
+          if (this._text.charCodeAt(i0 + (2)) == (110) && this._text.charCodeAt(i0 + (3)) == (97) && this._text.charCodeAt(i0 + (4)) == (108)) return (98);
+        }
+      }
+      else if (ch == (115)) {
+        if (this._text.charCodeAt(i0 + (1)) == (117) && this._text.charCodeAt(i0 + (2)) == (112) && this._text.charCodeAt(i0 + (3)) == (101) && this._text.charCodeAt(i0 + (4)) == (114)) return (107);
+      }
+      else if (ch == (116)) {
+        if (this._text.charCodeAt(i0 + (1)) == (104) && this._text.charCodeAt(i0 + (2)) == (114) && this._text.charCodeAt(i0 + (3)) == (111) && this._text.charCodeAt(i0 + (4)) == (119)) return (110);
+      }
+      else if (ch == (119)) {
+        if (this._text.charCodeAt(i0 + (1)) == (104) && this._text.charCodeAt(i0 + (2)) == (105) && this._text.charCodeAt(i0 + (3)) == (108) && this._text.charCodeAt(i0 + (4)) == (101)) return (115);
+      }
+      return (70);
+
+    case (6):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (97)) {
+        if (this._text.charCodeAt(i0 + (1)) == (115) && this._text.charCodeAt(i0 + (2)) == (115) && this._text.charCodeAt(i0 + (3)) == (101) && this._text.charCodeAt(i0 + (4)) == (114) && this._text.charCodeAt(i0 + (5)) == (116)) return (72);
+      }
+      else if (ch == (105)) {
+        if (this._text.charCodeAt(i0 + (1)) == (109) && this._text.charCodeAt(i0 + (2)) == (112) && this._text.charCodeAt(i0 + (3)) == (111) && this._text.charCodeAt(i0 + (4)) == (114) && this._text.charCodeAt(i0 + (5)) == (116)) return (76);
+      }
+      else if (ch == (110)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (97)) {
+          if (this._text.charCodeAt(i0 + (2)) == (116) && this._text.charCodeAt(i0 + (3)) == (105) && this._text.charCodeAt(i0 + (4)) == (118) && this._text.charCodeAt(i0 + (5)) == (101)) return (79);
+        }
+        else if (ch == (101)) {
+          if (this._text.charCodeAt(i0 + (2)) == (103) && this._text.charCodeAt(i0 + (3)) == (97) && this._text.charCodeAt(i0 + (4)) == (116) && this._text.charCodeAt(i0 + (5)) == (101)) return (80);
+        }
+      }
+      else if (ch == (114)) {
+        if (this._text.charCodeAt(i0 + (1)) == (101) && this._text.charCodeAt(i0 + (2)) == (116) && this._text.charCodeAt(i0 + (3)) == (117) && this._text.charCodeAt(i0 + (4)) == (114) && this._text.charCodeAt(i0 + (5)) == (110)) return (106);
+      }
+      else if (ch == (115)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (111)) {
+          if (this._text.charCodeAt(i0 + (2)) == (117) && this._text.charCodeAt(i0 + (3)) == (114) && this._text.charCodeAt(i0 + (4)) == (99) && this._text.charCodeAt(i0 + (5)) == (101)) return (83);
+        }
+        else if (ch == (116)) {
+          if (this._text.charCodeAt(i0 + (2)) == (97) && this._text.charCodeAt(i0 + (3)) == (116) && this._text.charCodeAt(i0 + (4)) == (105) && this._text.charCodeAt(i0 + (5)) == (99)) return (84);
+        }
+        else if (ch == (119)) {
+          if (this._text.charCodeAt(i0 + (2)) == (105) && this._text.charCodeAt(i0 + (3)) == (116) && this._text.charCodeAt(i0 + (4)) == (99) && this._text.charCodeAt(i0 + (5)) == (104)) return (108);
+        }
+      }
+      return (70);
+
+    case (7):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (100)) {
+        if (this._text.charCodeAt(i0 + (1)) == (101) && this._text.charCodeAt(i0 + (2)) == (102) && this._text.charCodeAt(i0 + (3)) == (97) && this._text.charCodeAt(i0 + (4)) == (117) && this._text.charCodeAt(i0 + (5)) == (108) && this._text.charCodeAt(i0 + (6)) == (116)) return (93);
+      }
+      else if (ch == (101)) {
+        if (this._text.charCodeAt(i0 + (1)) == (120) && this._text.charCodeAt(i0 + (2)) == (116) && this._text.charCodeAt(i0 + (3)) == (101) && this._text.charCodeAt(i0 + (4)) == (110) && this._text.charCodeAt(i0 + (5)) == (100) && this._text.charCodeAt(i0 + (6)) == (115)) return (96);
+      }
+      else if (ch == (102)) {
+        ch = this._text.charCodeAt(i0 + (1));
+        if (ch == (97)) {
+          if (this._text.charCodeAt(i0 + (2)) == (99) && this._text.charCodeAt(i0 + (3)) == (116) && this._text.charCodeAt(i0 + (4)) == (111) && this._text.charCodeAt(i0 + (5)) == (114) && this._text.charCodeAt(i0 + (6)) == (121)) return (73);
+        }
+        else if (ch == (105)) {
+          if (this._text.charCodeAt(i0 + (2)) == (110) && this._text.charCodeAt(i0 + (3)) == (97) && this._text.charCodeAt(i0 + (4)) == (108) && this._text.charCodeAt(i0 + (5)) == (108) && this._text.charCodeAt(i0 + (6)) == (121)) return (99);
+        }
+      }
+      else if (ch == (108)) {
+        if (this._text.charCodeAt(i0 + (1)) == (105) && this._text.charCodeAt(i0 + (2)) == (98) && this._text.charCodeAt(i0 + (3)) == (114) && this._text.charCodeAt(i0 + (4)) == (97) && this._text.charCodeAt(i0 + (5)) == (114) && this._text.charCodeAt(i0 + (6)) == (121)) return (78);
+      }
+      else if (ch == (116)) {
+        if (this._text.charCodeAt(i0 + (1)) == (121) && this._text.charCodeAt(i0 + (2)) == (112) && this._text.charCodeAt(i0 + (3)) == (101) && this._text.charCodeAt(i0 + (4)) == (100) && this._text.charCodeAt(i0 + (5)) == (101) && this._text.charCodeAt(i0 + (6)) == (102)) return (85);
+      }
+      return (70);
+
+    case (8):
+
+      ch = this._text.charCodeAt(i0);
+      if (ch == (97)) {
+        if (this._text.charCodeAt(i0 + (1)) == (98) && this._text.charCodeAt(i0 + (2)) == (115) && this._text.charCodeAt(i0 + (3)) == (116) && this._text.charCodeAt(i0 + (4)) == (114) && this._text.charCodeAt(i0 + (5)) == (97) && this._text.charCodeAt(i0 + (6)) == (99) && this._text.charCodeAt(i0 + (7)) == (116)) return (71);
+      }
+      else if (ch == (99)) {
+        if (this._text.charCodeAt(i0 + (1)) == (111) && this._text.charCodeAt(i0 + (2)) == (110) && this._text.charCodeAt(i0 + (3)) == (116) && this._text.charCodeAt(i0 + (4)) == (105) && this._text.charCodeAt(i0 + (5)) == (110) && this._text.charCodeAt(i0 + (6)) == (117) && this._text.charCodeAt(i0 + (7)) == (101)) return (92);
+      }
+      else if (ch == (111)) {
+        if (this._text.charCodeAt(i0 + (1)) == (112) && this._text.charCodeAt(i0 + (2)) == (101) && this._text.charCodeAt(i0 + (3)) == (114) && this._text.charCodeAt(i0 + (4)) == (97) && this._text.charCodeAt(i0 + (5)) == (116) && this._text.charCodeAt(i0 + (6)) == (111) && this._text.charCodeAt(i0 + (7)) == (114)) return (81);
+      }
+      return (70);
+
+    case (9):
+
+      if (this._text.charCodeAt(i0) == (105) && this._text.charCodeAt(i0 + (1)) == (110) && this._text.charCodeAt(i0 + (2)) == (116) && this._text.charCodeAt(i0 + (3)) == (101) && this._text.charCodeAt(i0 + (4)) == (114) && this._text.charCodeAt(i0 + (5)) == (102) && this._text.charCodeAt(i0 + (6)) == (97) && this._text.charCodeAt(i0 + (7)) == (99) && this._text.charCodeAt(i0 + (8)) == (101)) return (77);
+      return (70);
+
+    case (10):
+
+      if (this._text.charCodeAt(i0) == (105) && this._text.charCodeAt(i0 + (1)) == (109) && this._text.charCodeAt(i0 + (2)) == (112) && this._text.charCodeAt(i0 + (3)) == (108) && this._text.charCodeAt(i0 + (4)) == (101) && this._text.charCodeAt(i0 + (5)) == (109) && this._text.charCodeAt(i0 + (6)) == (101) && this._text.charCodeAt(i0 + (7)) == (110) && this._text.charCodeAt(i0 + (8)) == (116) && this._text.charCodeAt(i0 + (9)) == (115)) return (75);
+      return (70);
 
     default:
 
-      return 70/*TokenKind.IDENTIFIER*/;
+      return (70);
 
   }
 }
 Tokenizer.prototype.next$0 = Tokenizer.prototype.next;
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
-    case 1/*TokenKind.END_OF_FILE*/:
+    case (1):
 
       return "end of file";
 
-    case 2/*TokenKind.LPAREN*/:
+    case (2):
 
       return "(";
 
-    case 3/*TokenKind.RPAREN*/:
+    case (3):
 
       return ")";
 
-    case 4/*TokenKind.LBRACK*/:
+    case (4):
 
       return "[";
 
-    case 5/*TokenKind.RBRACK*/:
+    case (5):
 
       return "]";
 
-    case 6/*TokenKind.LBRACE*/:
+    case (6):
 
       return "{";
 
-    case 7/*TokenKind.RBRACE*/:
+    case (7):
 
       return "}";
 
-    case 8/*TokenKind.COLON*/:
+    case (8):
 
       return ":";
 
-    case 9/*TokenKind.ARROW*/:
+    case (9):
 
       return "=>";
 
-    case 10/*TokenKind.SEMICOLON*/:
+    case (10):
 
       return ";";
 
-    case 11/*TokenKind.COMMA*/:
+    case (11):
 
       return ",";
 
-    case 12/*TokenKind.HASH*/:
+    case (12):
 
       return "#";
 
-    case 13/*TokenKind.HASHBANG*/:
+    case (13):
 
       return "#!";
 
-    case 14/*TokenKind.DOT*/:
+    case (14):
 
       return ".";
 
-    case 15/*TokenKind.ELLIPSIS*/:
+    case (15):
 
       return "...";
 
-    case 16/*TokenKind.INCR*/:
+    case (16):
 
       return "++";
 
-    case 17/*TokenKind.DECR*/:
+    case (17):
 
       return "--";
 
-    case 18/*TokenKind.BIT_NOT*/:
+    case (18):
 
       return "~";
 
-    case 19/*TokenKind.NOT*/:
+    case (19):
 
       return "!";
 
-    case 20/*TokenKind.ASSIGN*/:
+    case (20):
 
       return "=";
 
-    case 21/*TokenKind.ASSIGN_OR*/:
+    case (21):
 
       return "|=";
 
-    case 22/*TokenKind.ASSIGN_XOR*/:
+    case (22):
 
       return "^=";
 
-    case 23/*TokenKind.ASSIGN_AND*/:
+    case (23):
 
       return "&=";
 
-    case 24/*TokenKind.ASSIGN_SHL*/:
+    case (24):
 
       return "<<=";
 
-    case 25/*TokenKind.ASSIGN_SAR*/:
+    case (25):
 
       return ">>=";
 
-    case 26/*TokenKind.ASSIGN_SHR*/:
+    case (26):
 
       return ">>>=";
 
-    case 27/*TokenKind.ASSIGN_ADD*/:
+    case (27):
 
       return "+=";
 
-    case 28/*TokenKind.ASSIGN_SUB*/:
+    case (28):
 
       return "-=";
 
-    case 29/*TokenKind.ASSIGN_MUL*/:
+    case (29):
 
       return "*=";
 
-    case 30/*TokenKind.ASSIGN_DIV*/:
+    case (30):
 
       return "/=";
 
-    case 31/*TokenKind.ASSIGN_TRUNCDIV*/:
+    case (31):
 
       return "~/=";
 
-    case 32/*TokenKind.ASSIGN_MOD*/:
+    case (32):
 
       return "%=";
 
-    case 33/*TokenKind.CONDITIONAL*/:
+    case (33):
 
       return "?";
 
-    case 34/*TokenKind.OR*/:
+    case (34):
 
       return "||";
 
-    case 35/*TokenKind.AND*/:
+    case (35):
 
       return "&&";
 
-    case 36/*TokenKind.BIT_OR*/:
+    case (36):
 
       return "|";
 
-    case 37/*TokenKind.BIT_XOR*/:
+    case (37):
 
       return "^";
 
-    case 38/*TokenKind.BIT_AND*/:
+    case (38):
 
       return "&";
 
-    case 39/*TokenKind.SHL*/:
+    case (39):
 
       return "<<";
 
-    case 40/*TokenKind.SAR*/:
+    case (40):
 
       return ">>";
 
-    case 41/*TokenKind.SHR*/:
+    case (41):
 
       return ">>>";
 
-    case 42/*TokenKind.ADD*/:
+    case (42):
 
       return "+";
 
-    case 43/*TokenKind.SUB*/:
+    case (43):
 
       return "-";
 
-    case 44/*TokenKind.MUL*/:
+    case (44):
 
       return "*";
 
-    case 45/*TokenKind.DIV*/:
+    case (45):
 
       return "/";
 
-    case 46/*TokenKind.TRUNCDIV*/:
+    case (46):
 
       return "~/";
 
-    case 47/*TokenKind.MOD*/:
+    case (47):
 
       return "%";
 
-    case 48/*TokenKind.EQ*/:
+    case (48):
 
       return "==";
 
-    case 49/*TokenKind.NE*/:
+    case (49):
 
       return "!=";
 
-    case 50/*TokenKind.EQ_STRICT*/:
+    case (50):
 
       return "===";
 
-    case 51/*TokenKind.NE_STRICT*/:
+    case (51):
 
       return "!==";
 
-    case 52/*TokenKind.LT*/:
+    case (52):
 
       return "<";
 
-    case 53/*TokenKind.GT*/:
+    case (53):
 
       return ">";
 
-    case 54/*TokenKind.LTE*/:
+    case (54):
 
       return "<=";
 
-    case 55/*TokenKind.GTE*/:
+    case (55):
 
       return ">=";
 
-    case 56/*TokenKind.INDEX*/:
+    case (56):
 
       return "[]";
 
-    case 57/*TokenKind.SETINDEX*/:
+    case (57):
 
       return "[]=";
 
-    case 58/*TokenKind.STRING*/:
+    case (58):
 
       return "string";
 
-    case 59/*TokenKind.STRING_PART*/:
+    case (59):
 
       return "string part";
 
-    case 60/*TokenKind.INTEGER*/:
+    case (60):
 
       return "integer";
 
-    case 61/*TokenKind.HEX_INTEGER*/:
+    case (61):
 
       return "hex integer";
 
-    case 62/*TokenKind.DOUBLE*/:
+    case (62):
 
       return "double";
 
-    case 63/*TokenKind.WHITESPACE*/:
+    case (63):
 
       return "whitespace";
 
-    case 64/*TokenKind.COMMENT*/:
+    case (64):
 
       return "comment";
 
-    case 65/*TokenKind.ERROR*/:
+    case (65):
 
       return "error";
 
-    case 66/*TokenKind.INCOMPLETE_STRING*/:
+    case (66):
 
       return "incomplete string";
 
-    case 67/*TokenKind.INCOMPLETE_COMMENT*/:
+    case (67):
 
       return "incomplete comment";
 
-    case 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/:
+    case (68):
 
       return "incomplete multiline string dq";
 
-    case 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/:
+    case (69):
 
       return "incomplete multiline string sq";
 
-    case 70/*TokenKind.IDENTIFIER*/:
+    case (70):
 
       return "identifier";
 
-    case 71/*TokenKind.ABSTRACT*/:
+    case (71):
 
       return "pseudo-keyword 'abstract'";
 
-    case 72/*TokenKind.ASSERT*/:
+    case (72):
 
       return "pseudo-keyword 'assert'";
 
-    case 90/*TokenKind.CLASS*/:
+    case (90):
 
       return "pseudo-keyword 'class'";
 
-    case 96/*TokenKind.EXTENDS*/:
+    case (96):
 
       return "pseudo-keyword 'extends'";
 
-    case 73/*TokenKind.FACTORY*/:
+    case (73):
 
       return "pseudo-keyword 'factory'";
 
-    case 74/*TokenKind.GET*/:
+    case (74):
 
       return "pseudo-keyword 'get'";
 
-    case 75/*TokenKind.IMPLEMENTS*/:
+    case (75):
 
       return "pseudo-keyword 'implements'";
 
-    case 76/*TokenKind.IMPORT*/:
+    case (76):
 
       return "pseudo-keyword 'import'";
 
-    case 77/*TokenKind.INTERFACE*/:
+    case (77):
 
       return "pseudo-keyword 'interface'";
 
-    case 78/*TokenKind.LIBRARY*/:
+    case (78):
 
       return "pseudo-keyword 'library'";
 
-    case 79/*TokenKind.NATIVE*/:
+    case (79):
 
       return "pseudo-keyword 'native'";
 
-    case 80/*TokenKind.NEGATE*/:
+    case (80):
 
       return "pseudo-keyword 'negate'";
 
-    case 81/*TokenKind.OPERATOR*/:
+    case (81):
 
       return "pseudo-keyword 'operator'";
 
-    case 82/*TokenKind.SET*/:
+    case (82):
 
       return "pseudo-keyword 'set'";
 
-    case 83/*TokenKind.SOURCE*/:
+    case (83):
 
       return "pseudo-keyword 'source'";
 
-    case 84/*TokenKind.STATIC*/:
+    case (84):
 
       return "pseudo-keyword 'static'";
 
-    case 85/*TokenKind.TYPEDEF*/:
+    case (85):
 
       return "pseudo-keyword 'typedef'";
 
-    case 86/*TokenKind.AWAIT*/:
+    case (86):
 
       return "keyword 'await'";
 
-    case 87/*TokenKind.BREAK*/:
+    case (87):
 
       return "keyword 'break'";
 
-    case 88/*TokenKind.CASE*/:
+    case (88):
 
       return "keyword 'case'";
 
-    case 89/*TokenKind.CATCH*/:
+    case (89):
 
       return "keyword 'catch'";
 
-    case 91/*TokenKind.CONST*/:
+    case (91):
 
       return "keyword 'const'";
 
-    case 92/*TokenKind.CONTINUE*/:
+    case (92):
 
       return "keyword 'continue'";
 
-    case 93/*TokenKind.DEFAULT*/:
+    case (93):
 
       return "keyword 'default'";
 
-    case 94/*TokenKind.DO*/:
+    case (94):
 
       return "keyword 'do'";
 
-    case 95/*TokenKind.ELSE*/:
+    case (95):
 
       return "keyword 'else'";
 
-    case 97/*TokenKind.FALSE*/:
+    case (97):
 
       return "keyword 'false'";
 
-    case 98/*TokenKind.FINAL*/:
+    case (98):
 
       return "keyword 'final'";
 
-    case 99/*TokenKind.FINALLY*/:
+    case (99):
 
       return "keyword 'finally'";
 
-    case 100/*TokenKind.FOR*/:
+    case (100):
 
       return "keyword 'for'";
 
-    case 101/*TokenKind.IF*/:
+    case (101):
 
       return "keyword 'if'";
 
-    case 102/*TokenKind.IN*/:
+    case (102):
 
       return "keyword 'in'";
 
-    case 103/*TokenKind.IS*/:
+    case (103):
 
       return "keyword 'is'";
 
-    case 104/*TokenKind.NEW*/:
+    case (104):
 
       return "keyword 'new'";
 
-    case 105/*TokenKind.NULL*/:
+    case (105):
 
       return "keyword 'null'";
 
-    case 106/*TokenKind.RETURN*/:
+    case (106):
 
       return "keyword 'return'";
 
-    case 107/*TokenKind.SUPER*/:
+    case (107):
 
       return "keyword 'super'";
 
-    case 108/*TokenKind.SWITCH*/:
+    case (108):
 
       return "keyword 'switch'";
 
-    case 109/*TokenKind.THIS*/:
+    case (109):
 
       return "keyword 'this'";
 
-    case 110/*TokenKind.THROW*/:
+    case (110):
 
       return "keyword 'throw'";
 
-    case 111/*TokenKind.TRUE*/:
+    case (111):
 
       return "keyword 'true'";
 
-    case 112/*TokenKind.TRY*/:
+    case (112):
 
       return "keyword 'try'";
 
-    case 113/*TokenKind.VAR*/:
+    case (113):
 
       return "keyword 'var'";
 
-    case 114/*TokenKind.VOID*/:
+    case (114):
 
       return "keyword 'void'";
 
-    case 115/*TokenKind.WHILE*/:
+    case (115):
 
       return "keyword 'while'";
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
-  return kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 86/*TokenKind.AWAIT*/;
+  return kind >= (70) && kind < (86);
 }
 TokenKind.infixPrecedence = function(kind) {
   switch (kind) {
-    case 20/*TokenKind.ASSIGN*/:
+    case (20):
 
-      return 2;
+      return (2);
 
-    case 21/*TokenKind.ASSIGN_OR*/:
+    case (21):
 
-      return 2;
+      return (2);
 
-    case 22/*TokenKind.ASSIGN_XOR*/:
+    case (22):
 
-      return 2;
+      return (2);
 
-    case 23/*TokenKind.ASSIGN_AND*/:
+    case (23):
 
-      return 2;
+      return (2);
 
-    case 24/*TokenKind.ASSIGN_SHL*/:
+    case (24):
 
-      return 2;
+      return (2);
 
-    case 25/*TokenKind.ASSIGN_SAR*/:
+    case (25):
 
-      return 2;
+      return (2);
 
-    case 26/*TokenKind.ASSIGN_SHR*/:
+    case (26):
 
-      return 2;
+      return (2);
 
-    case 27/*TokenKind.ASSIGN_ADD*/:
+    case (27):
 
-      return 2;
+      return (2);
 
-    case 28/*TokenKind.ASSIGN_SUB*/:
+    case (28):
 
-      return 2;
+      return (2);
 
-    case 29/*TokenKind.ASSIGN_MUL*/:
+    case (29):
 
-      return 2;
+      return (2);
 
-    case 30/*TokenKind.ASSIGN_DIV*/:
+    case (30):
 
-      return 2;
+      return (2);
 
-    case 31/*TokenKind.ASSIGN_TRUNCDIV*/:
+    case (31):
 
-      return 2;
+      return (2);
 
-    case 32/*TokenKind.ASSIGN_MOD*/:
+    case (32):
 
-      return 2;
+      return (2);
 
-    case 33/*TokenKind.CONDITIONAL*/:
+    case (33):
 
-      return 3;
+      return (3);
 
-    case 34/*TokenKind.OR*/:
+    case (34):
 
-      return 4;
+      return (4);
 
-    case 35/*TokenKind.AND*/:
+    case (35):
 
-      return 5;
+      return (5);
 
-    case 36/*TokenKind.BIT_OR*/:
+    case (36):
 
-      return 6;
+      return (6);
 
-    case 37/*TokenKind.BIT_XOR*/:
+    case (37):
 
-      return 7;
+      return (7);
 
-    case 38/*TokenKind.BIT_AND*/:
+    case (38):
 
-      return 8;
+      return (8);
 
-    case 39/*TokenKind.SHL*/:
+    case (39):
 
-      return 11;
+      return (11);
 
-    case 40/*TokenKind.SAR*/:
+    case (40):
 
-      return 11;
+      return (11);
 
-    case 41/*TokenKind.SHR*/:
+    case (41):
 
-      return 11;
+      return (11);
 
-    case 42/*TokenKind.ADD*/:
+    case (42):
 
-      return 12;
+      return (12);
 
-    case 43/*TokenKind.SUB*/:
+    case (43):
 
-      return 12;
+      return (12);
 
-    case 44/*TokenKind.MUL*/:
+    case (44):
 
-      return 13;
+      return (13);
 
-    case 45/*TokenKind.DIV*/:
+    case (45):
 
-      return 13;
+      return (13);
 
-    case 46/*TokenKind.TRUNCDIV*/:
+    case (46):
 
-      return 13;
+      return (13);
 
-    case 47/*TokenKind.MOD*/:
+    case (47):
 
-      return 13;
+      return (13);
 
-    case 48/*TokenKind.EQ*/:
+    case (48):
 
-      return 9;
+      return (9);
 
-    case 49/*TokenKind.NE*/:
+    case (49):
 
-      return 9;
+      return (9);
 
-    case 50/*TokenKind.EQ_STRICT*/:
+    case (50):
 
-      return 9;
+      return (9);
 
-    case 51/*TokenKind.NE_STRICT*/:
+    case (51):
 
-      return 9;
+      return (9);
 
-    case 52/*TokenKind.LT*/:
+    case (52):
 
-      return 10;
+      return (10);
 
-    case 53/*TokenKind.GT*/:
+    case (53):
 
-      return 10;
+      return (10);
 
-    case 54/*TokenKind.LTE*/:
+    case (54):
 
-      return 10;
+      return (10);
 
-    case 55/*TokenKind.GTE*/:
+    case (55):
 
-      return 10;
+      return (10);
 
-    case 103/*TokenKind.IS*/:
+    case (103):
 
-      return 10;
+      return (10);
 
     default:
 
-      return -1;
+      return (-1);
 
   }
 }
 TokenKind.rawOperatorFromMethod = function(name) {
   switch (name) {
     case ":bit_not":
 
       return "~";
 
     case ":bit_or":
@@ skipping 73 matching lines @@
       return "[]=";
 
     case ":ne":
 
       return "!=";
 
   }
 }
 TokenKind.binaryMethodName = function(kind) {
   switch (kind) {
-    case 18/*TokenKind.BIT_NOT*/:
+    case (18):
 
       return ":bit_not";
 
-    case 36/*TokenKind.BIT_OR*/:
+    case (36):
 
       return ":bit_or";
 
-    case 37/*TokenKind.BIT_XOR*/:
+    case (37):
 
       return ":bit_xor";
 
-    case 38/*TokenKind.BIT_AND*/:
+    case (38):
 
       return ":bit_and";
 
-    case 39/*TokenKind.SHL*/:
+    case (39):
 
       return ":shl";
 
-    case 40/*TokenKind.SAR*/:
+    case (40):
 
       return ":sar";
 
-    case 41/*TokenKind.SHR*/:
+    case (41):
 
       return ":shr";
 
-    case 42/*TokenKind.ADD*/:
+    case (42):
 
       return ":add";
 
-    case 43/*TokenKind.SUB*/:
+    case (43):
 
       return ":sub";
 
-    case 44/*TokenKind.MUL*/:
+    case (44):
 
       return ":mul";
 
-    case 45/*TokenKind.DIV*/:
+    case (45):
 
       return ":div";
 
-    case 46/*TokenKind.TRUNCDIV*/:
+    case (46):
 
       return ":truncdiv";
 
-    case 47/*TokenKind.MOD*/:
+    case (47):
 
       return ":mod";
 
-    case 48/*TokenKind.EQ*/:
+    case (48):
 
       return ":eq";
 
-    case 52/*TokenKind.LT*/:
+    case (52):
 
       return ":lt";
 
-    case 53/*TokenKind.GT*/:
+    case (53):
 
       return ":gt";
 
-    case 54/*TokenKind.LTE*/:
+    case (54):
 
       return ":lte";
 
-    case 55/*TokenKind.GTE*/:
+    case (55):
 
       return ":gte";
 
-    case 56/*TokenKind.INDEX*/:
+    case (56):
 
       return ":index";
 
-    case 57/*TokenKind.SETINDEX*/:
+    case (57):
 
       return ":setindex";
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
-  if (kind == 20/*TokenKind.ASSIGN*/) return 0;
-  if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
+  if (kind == (20)) return (0);
+  if (kind > (20) && kind <= (32)) {
     return kind + (15);
   }
-  return -1;
+  return (-1);
 }
 // ********** Code for Parser **************
 function Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
   this._inhibitLambda = false
-  this._afterParensIndex = 0
+  this._afterParensIndex = (0)
   this._recover = false
   this.source = source;
   this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
   this.optionalSemicolons = optionalSemicolons;
   // Initializers done
   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/*TokenKind.END_OF_FILE*/)) {
+  if (this.throwOnIncomplete && this._maybeEat((1))) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
-  else if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
+  else if (this._maybeEat((1))) {
     this._lang_error("unexpected end of file", this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
 Parser.prototype._recoverTo = function(kind1, kind2, kind3) {
   while (!this.isPrematureEndOfFile()) {
     var kind = this._peek();
@@ skipping 13 matching lines @@
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
 Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
 Parser.prototype._peekIdentifier = function() {
   return this._isIdentifier(this._peekToken.kind);
 }
 Parser.prototype._isIdentifier = function(kind) {
-  return TokenKind.isIdentifier(kind) || (!this.get$enableAwait() && $eq(kind, 86/*TokenKind.AWAIT*/));
+  return TokenKind.isIdentifier(kind) || (!this.get$enableAwait() && $eq(kind, (86)));
 }
 Parser.prototype._maybeEat = function(kind) {
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
 Parser.prototype._eat = function(kind) {
   if (!this._maybeEat(kind)) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 Parser.prototype._eatSemicolon = function() {
-  if (this.optionalSemicolons && this._peekKind(1/*TokenKind.END_OF_FILE*/)) return;
-  this._eat(10/*TokenKind.SEMICOLON*/);
+  if (this.optionalSemicolons && this._peekKind((1))) return;
+  this._eat((10));
 }
 Parser.prototype._errorExpected = function(expected) {
   if (this.throwOnIncomplete) this.isPrematureEndOfFile();
   var tok = this._lang_next();
   if ((tok instanceof ErrorToken) && tok.get$message() != null) {
     this._lang_error(tok.get$message(), tok.get$span());
   }
   else {
     this._lang_error(("expected " + expected + ", but found " + tok), tok.get$span());
   }
 }
 Parser.prototype._lang_error = function(message, location) {
   if (this._recover) return;
   if (location == null) {
     location = this._peekToken.get$span();
   }
   $globals.world.fatal(message, location);
   this._recover = true;
 }
 Parser.prototype._skipBlock = function() {
-  var depth = 1;
-  this._eat(6/*TokenKind.LBRACE*/);
+  var depth = (1);
+  this._eat((6));
   while (true) {
     var tok = this._lang_next();
-    if ($eq(tok.get$kind(), 6/*TokenKind.LBRACE*/)) {
-      depth += 1;
+    if ($eq(tok.get$kind(), (6))) {
+      depth += (1);
     }
-    else if ($eq(tok.get$kind(), 7/*TokenKind.RBRACE*/)) {
-      depth -= 1;
-      if (depth == 0) return;
+    else if ($eq(tok.get$kind(), (7))) {
+      depth -= (1);
+      if (depth == (0)) return;
     }
-    else if ($eq(tok.get$kind(), 1/*TokenKind.END_OF_FILE*/)) {
+    else if ($eq(tok.get$kind(), (1))) {
       this._lang_error("unexpected end of file during diet parse", tok.get$span());
       return;
     }
   }
 }
 Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 Parser.prototype.compilationUnit = function() {
   var ret = [];
-  this._maybeEat(13/*TokenKind.HASHBANG*/);
-  while (this._peekKind(12/*TokenKind.HASH*/)) {
+  this._maybeEat((13));
+  while (this._peekKind((12))) {
     ret.add$1(this.directive());
   }
   this._recover = false;
-  while (!this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
+  while (!this._maybeEat((1))) {
     ret.add$1(this.topLevelDefinition());
   }
   this._recover = false;
   return ret;
 }
 Parser.prototype.directive = function() {
   var start = this._peekToken.start;
-  this._eat(12/*TokenKind.HASH*/);
+  this._eat((12));
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
 Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
-    case 90/*TokenKind.CLASS*/:
+    case (90):
 
-      return this.classDefinition(90/*TokenKind.CLASS*/);
+      return this.classDefinition((90));
 
-    case 77/*TokenKind.INTERFACE*/:
+    case (77):
 
-      return this.classDefinition(77/*TokenKind.INTERFACE*/);
+      return this.classDefinition((77));
 
-    case 85/*TokenKind.TYPEDEF*/:
+    case (85):
 
       return this.functionTypeAlias();
 
     default:
 
       return this.declaration(true);
 
   }
 }
 Parser.prototype.classDefinition = function(kind) {
   var start = this._peekToken.start;
   this._eat(kind);
   var name = this.identifier();
   var typeParams = null;
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if (this._peekKind((52))) {
     typeParams = this.typeParameters();
   }
   var _extends = null;
-  if (this._maybeEat(96/*TokenKind.EXTENDS*/)) {
+  if (this._maybeEat((96))) {
     _extends = this.typeList();
   }
   var _implements = null;
-  if (this._maybeEat(75/*TokenKind.IMPLEMENTS*/)) {
+  if (this._maybeEat((75))) {
     _implements = this.typeList();
   }
   var _native = null;
-  if (this._maybeEat(79/*TokenKind.NATIVE*/)) {
+  if (this._maybeEat((79))) {
     _native = this.maybeStringLiteral();
     if (_native != null) _native = new NativeType(_native);
   }
-  var oldFactory = this._maybeEat(73/*TokenKind.FACTORY*/);
+  var oldFactory = this._maybeEat((73));
   var defaultType = null;
-  if (oldFactory || this._maybeEat(93/*TokenKind.DEFAULT*/)) {
+  if (oldFactory || this._maybeEat((93))) {
     if (oldFactory) {
       $globals.world.warning("factory no longer supported, use \"default\" instead", this._previousToken.get$span());
     }
     var baseType = this.nameTypeReference();
     var typeParams0 = null;
-    if (this._peekKind(52/*TokenKind.LT*/)) {
+    if (this._peekKind((52))) {
       typeParams0 = this.typeParameters();
     }
     defaultType = new DefaultTypeReference(oldFactory, baseType, typeParams0, this._makeSpan(baseType.get$span().get$start()));
   }
   var body = [];
-  if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
-    while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
+  if (this._maybeEat((6))) {
+    while (!this._maybeEat((7))) {
       body.add$1(this.declaration(true));
       if (this._recover) {
-        if (!this._recoverTo(7/*TokenKind.RBRACE*/, 10/*TokenKind.SEMICOLON*/)) break;
-        this._maybeEat(10/*TokenKind.SEMICOLON*/);
+        if (!this._recoverTo((7), (10))) break;
+        this._maybeEat((10));
       }
     }
   }
   else {
     this._errorExpected("block starting with \"{\" or \";\"");
   }
-  return new TypeDefinition(kind == 90/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, defaultType, body, this._makeSpan(start));
+  return new TypeDefinition(kind == (90), name, typeParams, _extends, _implements, _native, defaultType, body, this._makeSpan(start));
 }
 Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
-  this._eat(85/*TokenKind.TYPEDEF*/);
+  this._eat((85));
   var di = this.declaredIdentifier(false);
   var typeParams = null;
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if (this._peekKind((52))) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
   var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
 Parser.prototype.initializers = function() {
   this._inhibitLambda = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
+  while (this._maybeEat((11)))
   this._inhibitLambda = false;
   return ret;
 }
 Parser.prototype.get$initializers = function() {
   return this.initializers.bind(this);
 }
 Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
-  if (this._maybeEat(9/*TokenKind.ARROW*/)) {
+  if (this._maybeEat((9))) {
     var expr = this.expression();
     if (!inExpression) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
-  else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
+  else if (this._peekKind((6))) {
     if (this.diet) {
       this._skipBlock();
       return new DietStatement(this._makeSpan(start));
     }
     else {
       return this.block();
     }
   }
   else if (!inExpression) {
-    if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+    if (this._maybeEat((10))) {
       return null;
     }
   }
   this._lang_error("Expected function body (neither { nor => found)");
 }
 Parser.prototype.finishField = function(start, modifiers, type, name, value) {
   var names = [name];
   var values = [value];
-  while (this._maybeEat(11/*TokenKind.COMMA*/)) {
+  while (this._maybeEat((11))) {
     names.add$1(this.identifier());
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if (this._maybeEat((20))) {
       values.add$1(this.expression());
     }
     else {
       values.add$1();
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan(start));
 }
 Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
-    case 2/*TokenKind.LPAREN*/:
+    case (2):
 
       var formals = this.formalParameterList();
       var inits = null, native_ = null;
-      if (this._maybeEat(8/*TokenKind.COLON*/)) {
+      if (this._maybeEat((8))) {
         inits = this.initializers();
       }
-      if (this._maybeEat(79/*TokenKind.NATIVE*/)) {
+      if (this._maybeEat((79))) {
         native_ = this.maybeStringLiteral();
         if (native_ == null) native_ = "";
       }
       var body = this.functionBody(false);
       if (di.get$name() == null) {
         di.set$name(di.get$type().get$name());
       }
       return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, inits, native_, body, this._makeSpan(start));
 
-    case 20/*TokenKind.ASSIGN*/:
+    case (20):
 
-      this._eat(20/*TokenKind.ASSIGN*/);
+      this._eat((20));
       var value = this.expression();
       return this.finishField(start, modifiers, di.get$type(), di.get$name(), value);
 
-    case 11/*TokenKind.COMMA*/:
-    case 10/*TokenKind.SEMICOLON*/:
+    case (11):
+    case (10):
 
       return this.finishField(start, modifiers, di.get$type(), di.get$name(), null);
 
     default:
 
       this._errorExpected("declaration");
       return null;
 
   }
 }
 Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
-  if (this._peekKind(73/*TokenKind.FACTORY*/)) {
+  if (this._peekKind((73))) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
 Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
-  while (this._maybeEat(14/*TokenKind.DOT*/)) {
+  while (this._maybeEat((14))) {
     names.add$1(this.identifier());
   }
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if (this._peekKind((52))) {
     var tp = this.typeParameters();
-    $globals.world.warning("type parameters on factories are no longer supported, place them on the class instead", this._makeSpan(tp.$index(0).get$span().get$start()));
+    $globals.world.warning("type parameters on factories are no longer supported, place them on the class instead", this._makeSpan(tp.$index((0)).get$span().get$start()));
   }
   var name = null;
   var type = null;
-  if (this._maybeEat(14/*TokenKind.DOT*/)) {
+  if (this._maybeEat((14))) {
     name = this.identifier();
   }
   else {
-    if (names.get$length() > 1) {
+    if (names.get$length() > (1)) {
       name = names.removeLast$0();
     }
     else {
-      name = new Identifier("", names.$index(0).get$span());
+      name = new Identifier("", names.$index((0)).get$span());
     }
   }
-  if (names.get$length() > 1) {
-    this._lang_error("unsupported qualified name for factory", names.$index(0).get$span());
+  if (names.get$length() > (1)) {
+    this._lang_error("unsupported qualified name for factory", names.$index((0)).get$span());
   }
-  type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
+  type = new NameTypeReference(false, names.$index((0)), null, names.$index((0)).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 Parser.prototype.statement = function() {
   switch (this._peek()) {
-    case 87/*TokenKind.BREAK*/:
+    case (87):
 
       return this.breakStatement();
 
-    case 92/*TokenKind.CONTINUE*/:
+    case (92):
 
       return this.continueStatement();
 
-    case 106/*TokenKind.RETURN*/:
+    case (106):
 
       return this.returnStatement();
 
-    case 110/*TokenKind.THROW*/:
+    case (110):
 
       return this.throwStatement();
 
-    case 72/*TokenKind.ASSERT*/:
+    case (72):
 
       return this.assertStatement();
 
-    case 115/*TokenKind.WHILE*/:
+    case (115):
 
       return this.whileStatement();
 
-    case 94/*TokenKind.DO*/:
+    case (94):
 
       return this.doStatement();
 
-    case 100/*TokenKind.FOR*/:
+    case (100):
 
       return this.forStatement();
 
-    case 101/*TokenKind.IF*/:
+    case (101):
 
       return this.ifStatement();
 
-    case 108/*TokenKind.SWITCH*/:
+    case (108):
 
       return this.switchStatement();
 
-    case 112/*TokenKind.TRY*/:
+    case (112):
 
       return this.tryStatement();
 
-    case 6/*TokenKind.LBRACE*/:
+    case (6):
 
       return this.block();
 
-    case 10/*TokenKind.SEMICOLON*/:
+    case (10):
 
       return this.emptyStatement();
 
-    case 98/*TokenKind.FINAL*/:
+    case (98):
 
       return this.declaration(false);
 
-    case 113/*TokenKind.VAR*/:
+    case (113):
 
       return this.declaration(false);
 
     default:
 
       return this.finishExpressionAsStatement(this.expression());
 
   }
 }
 Parser.prototype.finishExpressionAsStatement = function(expr) {
   var start = expr.get$span().get$start();
-  if (this._maybeEat(8/*TokenKind.COLON*/)) {
+  if (this._maybeEat((8))) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
   if ((expr instanceof LambdaExpression)) {
     if (!(expr.get$func().get$body() instanceof BlockStatement)) {
       this._eatSemicolon();
       expr.get$func().set$span(this._makeSpan(start));
     }
     return expr.get$func();
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     var value = null;
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if (this._maybeEat((20))) {
       value = this.expression();
     }
     return this.finishField(start, null, expr.get$type(), expr.get$name(), value);
   }
-  else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.get$x() instanceof DeclaredIdentifier))) {
+  else if (this._isBin(expr, (20)) && ((expr.get$x() instanceof DeclaredIdentifier))) {
     var di = expr.get$x();
     return this.finishField(start, null, di.type, di.name, expr.get$y());
   }
-  else if (this._isBin(expr, 52/*TokenKind.LT*/) && this._maybeEat(11/*TokenKind.COMMA*/)) {
+  else if (this._isBin(expr, (52)) && this._maybeEat((11))) {
     var baseType = this._makeType(expr.get$x());
     var typeArgs = [this._makeType(expr.get$y())];
-    var gt = this._finishTypeArguments(baseType, 0, typeArgs);
+    var gt = this._finishTypeArguments(baseType, (0), typeArgs);
     var name = this.identifier();
     var value = null;
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if (this._maybeEat((20))) {
       value = this.expression();
     }
     return this.finishField(expr.get$span().get$start(), null, gt, name, value);
   }
   else {
     this._eatSemicolon();
     return new ExpressionStatement(expr, this._makeSpan(expr.get$span().get$start()));
   }
 }
 Parser.prototype.testCondition = function() {
   this._eatLeftParen();
   var ret = this.expression();
-  this._eat(3/*TokenKind.RPAREN*/);
+  this._eat((3));
   return ret;
 }
 Parser.prototype.block = function() {
   var start = this._peekToken.start;
-  this._eat(6/*TokenKind.LBRACE*/);
+  this._eat((6));
   var stmts = [];
-  while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
+  while (!this._maybeEat((7))) {
     stmts.add$1(this.statement());
-    if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 10/*TokenKind.SEMICOLON*/)) break;
+    if (this._recover && !this._recoverTo((7), (10))) break;
   }
   this._recover = false;
   return new BlockStatement(stmts, this._makeSpan(start));
 }
 Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
-  this._eat(10/*TokenKind.SEMICOLON*/);
+  this._eat((10));
   return new EmptyStatement(this._makeSpan(start));
 }
 Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
-  this._eat(101/*TokenKind.IF*/);
+  this._eat((101));
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
-  if (this._maybeEat(95/*TokenKind.ELSE*/)) {
+  if (this._maybeEat((95))) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
 Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
-  this._eat(115/*TokenKind.WHILE*/);
+  this._eat((115));
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
 Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
-  this._eat(94/*TokenKind.DO*/);
+  this._eat((94));
   var body = this.statement();
-  this._eat(115/*TokenKind.WHILE*/);
+  this._eat((115));
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
 Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
-  this._eat(100/*TokenKind.FOR*/);
+  this._eat((100));
   this._eatLeftParen();
   var init = this.forInitializerStatement(start);
   if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
-  if (!this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if (!this._maybeEat((10))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
-  if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
+  if (!this._maybeEat((3))) {
     step.add$1(this.expression());
-    while (this._maybeEat(11/*TokenKind.COMMA*/)) {
+    while (this._maybeEat((11))) {
       step.add$1(this.expression());
     }
-    this._eat(3/*TokenKind.RPAREN*/);
+    this._eat((3));
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
 Parser.prototype.forInitializerStatement = function(start) {
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if (this._maybeEat((10))) {
     return null;
   }
   else {
     var init = this.expression();
-    if (this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/)) {
-      this._eat(11/*TokenKind.COMMA*/);
+    if (this._peekKind((11)) && this._isBin(init, (52))) {
+      this._eat((11));
       var baseType = this._makeType(init.get$x());
       var typeArgs = [this._makeType(init.get$y())];
-      var gt = this._finishTypeArguments(baseType, 0, typeArgs);
+      var gt = this._finishTypeArguments(baseType, (0), typeArgs);
       var name = this.identifier();
       init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().get$start()));
     }
-    if (this._maybeEat(102/*TokenKind.IN*/)) {
+    if (this._maybeEat((102))) {
       return this._finishForIn(start, this._makeDeclaredIdentifier(init));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
 Parser.prototype._finishForIn = function(start, di) {
   var expr = this.expression();
-  this._eat(3/*TokenKind.RPAREN*/);
+  this._eat((3));
   var body = this.statement();
   return new ForInStatement(di, expr, body, this._makeSpan(start));
 }
 Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
-  this._eat(112/*TokenKind.TRY*/);
+  this._eat((112));
   var body = this.block();
   var catches = [];
-  while (this._peekKind(89/*TokenKind.CATCH*/)) {
+  while (this._peekKind((89))) {
     catches.add$1(this.catchNode());
   }
   var finallyBlock = null;
-  if (this._maybeEat(99/*TokenKind.FINALLY*/)) {
+  if (this._maybeEat((99))) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
 Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
-  this._eat(89/*TokenKind.CATCH*/);
+  this._eat((89));
   this._eatLeftParen();
   var exc = this.declaredIdentifier(false);
   var trace = null;
-  if (this._maybeEat(11/*TokenKind.COMMA*/)) {
+  if (this._maybeEat((11))) {
     trace = this.declaredIdentifier(false);
   }
-  this._eat(3/*TokenKind.RPAREN*/);
+  this._eat((3));
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
 Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
-  this._eat(108/*TokenKind.SWITCH*/);
+  this._eat((108));
   var test = this.testCondition();
   var cases = [];
-  this._eat(6/*TokenKind.LBRACE*/);
-  while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
+  this._eat((6));
+  while (!this._maybeEat((7))) {
     cases.add$1(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
 Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
-  return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 88/*TokenKind.CASE*/) || $eq(kind, 93/*TokenKind.DEFAULT*/);
+  return $eq(kind, (7)) || $eq(kind, (88)) || $eq(kind, (93));
 }
 Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if (this._peekIdentifier()) {
     label = this.identifier();
-    this._eat(8/*TokenKind.COLON*/);
+    this._eat((8));
   }
   var cases = [];
   while (true) {
-    if (this._maybeEat(88/*TokenKind.CASE*/)) {
+    if (this._maybeEat((88))) {
       cases.add$1(this.expression());
-      this._eat(8/*TokenKind.COLON*/);
+      this._eat((8));
     }
-    else if (this._maybeEat(93/*TokenKind.DEFAULT*/)) {
+    else if (this._maybeEat((93))) {
       cases.add$1();
-      this._eat(8/*TokenKind.COLON*/);
+      this._eat((8));
     }
     else {
       break;
     }
   }
-  if ($eq(cases.get$length(), 0)) {
+  if ($eq(cases.get$length(), (0))) {
     this._lang_error("case or default");
   }
   var stmts = [];
   while (!this._peekCaseEnd()) {
     stmts.add$1(this.statement());
-    if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 88/*TokenKind.CASE*/, 93/*TokenKind.DEFAULT*/)) {
+    if (this._recover && !this._recoverTo((7), (88), (93))) {
       break;
     }
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
 Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
-  this._eat(106/*TokenKind.RETURN*/);
+  this._eat((106));
   var expr;
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if (this._maybeEat((10))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ReturnStatement(expr, this._makeSpan(start));
 }
 Parser.prototype.throwStatement = function() {
   var start = this._peekToken.start;
-  this._eat(110/*TokenKind.THROW*/);
+  this._eat((110));
   var expr;
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if (this._maybeEat((10))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
 Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
-  this._eat(72/*TokenKind.ASSERT*/);
+  this._eat((72));
   this._eatLeftParen();
   var expr = this.expression();
-  this._eat(3/*TokenKind.RPAREN*/);
+  this._eat((3));
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
 Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
-  this._eat(87/*TokenKind.BREAK*/);
+  this._eat((87));
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
 Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
-  this._eat(92/*TokenKind.CONTINUE*/);
+  this._eat((92));
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
 Parser.prototype.expression = function() {
-  return this.infixExpression(0);
+  return this.infixExpression((0));
 }
 Parser.prototype._makeType = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
   }
   else if ((expr instanceof DotExpression)) {
     var type = this._makeType(expr.get$self());
     if (type.get$names() == null) {
       type.set$names([expr.get$name()]);
     }
     else {
       type.get$names().add$1(expr.get$name());
     }
     type.set$span(expr.get$span());
     return type;
   }
   else {
     this._lang_error("expected type reference");
     return null;
   }
 }
 Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
 Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().get$start())));
 }
 Parser.prototype._fixAsType = function(x) {
-  if (this._maybeEat(53/*TokenKind.GT*/)) {
+  if (this._maybeEat((53))) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
-    var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
+    var type = new GenericTypeReference(base, [typeParam], (0), this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
-    var firstParam = this.addTypeArguments(paramBase, 1);
+    var firstParam = this.addTypeArguments(paramBase, (1));
     var type;
-    if (firstParam.get$depth() <= 0) {
-      type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
+    if (firstParam.get$depth() <= (0)) {
+      type = new GenericTypeReference(base, [firstParam], (0), this._makeSpan(x.span.start));
     }
-    else if (this._maybeEat(11/*TokenKind.COMMA*/)) {
-      type = this._finishTypeArguments(base, 0, [firstParam]);
+    else if (this._maybeEat((11))) {
+      type = this._finishTypeArguments(base, (0), [firstParam]);
     }
     else {
-      this._eat(53/*TokenKind.GT*/);
-      type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
+      this._eat((53));
+      type = new GenericTypeReference(base, [firstParam], (0), this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
 Parser.prototype.finishInfixExpression = function(x, precedence) {
   while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if (prec >= precedence) {
-      if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
-        if (this._isBin(x, 52/*TokenKind.LT*/)) {
+      if (kind == (52) || kind == (53)) {
+        if (this._isBin(x, (52))) {
           return this._fixAsType(x);
         }
       }
       var op = this._lang_next();
-      if ($eq(op.get$kind(), 103/*TokenKind.IS*/)) {
-        var isTrue = !this._maybeEat(19/*TokenKind.NOT*/);
-        var typeRef = this.type(0);
+      if ($eq(op.get$kind(), (103))) {
+        var isTrue = !this._maybeEat((19));
+        var typeRef = this.type((0));
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
-      var y = this.infixExpression($eq(prec, 2) ? prec : prec + 1);
-      if ($eq(op.get$kind(), 33/*TokenKind.CONDITIONAL*/)) {
-        this._eat(8/*TokenKind.COLON*/);
+      var y = this.infixExpression($eq(prec, (2)) ? prec : prec + (1));
+      if ($eq(op.get$kind(), (33))) {
+        this._eat((8));
         var z = this.infixExpression(prec);
         x = new ConditionalExpression(x, y, z, this._makeSpan(x.span.start));
       }
       else {
         x = new BinaryExpression(op, x, y, this._makeSpan(x.span.start));
       }
     }
     else {
       break;
     }
   }
   return x;
 }
 Parser.prototype._isPrefixUnaryOperator = function(kind) {
   switch (kind) {
-    case 42/*TokenKind.ADD*/:
-    case 43/*TokenKind.SUB*/:
-    case 19/*TokenKind.NOT*/:
-    case 18/*TokenKind.BIT_NOT*/:
-    case 16/*TokenKind.INCR*/:
-    case 17/*TokenKind.DECR*/:
+    case (42):
+    case (43):
+    case (19):
+    case (18):
+    case (16):
+    case (17):
 
       return true;
 
     default:
 
       return false;
 
   }
 }
 Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
   if (this._isPrefixUnaryOperator(this._peek())) {
     var tok = this._lang_next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
-  else if (this.get$enableAwait() && this._maybeEat(86/*TokenKind.AWAIT*/)) {
+  else if (this.get$enableAwait() && this._maybeEat((86))) {
     var expr = this.unaryExpression();
     return new AwaitExpression(expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
 Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
-  if (this._maybeEat(15/*TokenKind.ELLIPSIS*/)) {
+  if (this._maybeEat((15))) {
     label = new Identifier("...", this._makeSpan(start));
   }
   expr = this.expression();
-  if (label == null && this._maybeEat(8/*TokenKind.COLON*/)) {
+  if (label == null && this._maybeEat((8))) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
 Parser.prototype.arguments = function() {
   var args = [];
   this._eatLeftParen();
   var saved = this._inhibitLambda;
   this._inhibitLambda = false;
-  if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
+  if (!this._maybeEat((3))) {
     do {
       args.add$1(this.argument());
     }
-    while (this._maybeEat(11/*TokenKind.COMMA*/))
-    this._eat(3/*TokenKind.RPAREN*/);
+    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/*TokenKind.LPAREN*/:
+    case (2):
 
       return this.finishCallOrLambdaExpression(expr);
 
-    case 4/*TokenKind.LBRACK*/:
+    case (4):
 
-      this._eat(4/*TokenKind.LBRACK*/);
+      this._eat((4));
       var index = this.expression();
-      this._eat(5/*TokenKind.RBRACK*/);
+      this._eat((5));
       return this.finishPostfixExpression(new IndexExpression(expr, index, this._makeSpan(expr.get$span().get$start())));
 
-    case 14/*TokenKind.DOT*/:
+    case (14):
 
-      this._eat(14/*TokenKind.DOT*/);
+      this._eat((14));
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().get$start()));
       return this.finishPostfixExpression(ret);
 
-    case 16/*TokenKind.INCR*/:
-    case 17/*TokenKind.DECR*/:
+    case (16):
+    case (17):
 
       var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().get$start()));
 
-    case 9/*TokenKind.ARROW*/:
-    case 6/*TokenKind.LBRACE*/:
+    case (9):
+    case (6):
 
       return expr;
 
     default:
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().get$start())));
       }
       else {
         return expr;
@@ skipping 17 matching lines @@
 }
 Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && $eq(expr.get$op().get$kind(), kind);
 }
 Parser.prototype._makeLiteral = function(value) {
   return new LiteralExpression(value, value.span);
 }
 Parser.prototype.primary = function() {
   var start = this._peekToken.start;
   switch (this._peek()) {
-    case 109/*TokenKind.THIS*/:
+    case (109):
 
-      this._eat(109/*TokenKind.THIS*/);
+      this._eat((109));
       return new ThisExpression(this._makeSpan(start));
 
-    case 107/*TokenKind.SUPER*/:
+    case (107):
 
-      this._eat(107/*TokenKind.SUPER*/);
+      this._eat((107));
       return new SuperExpression(this._makeSpan(start));
 
-    case 91/*TokenKind.CONST*/:
+    case (91):
 
-      this._eat(91/*TokenKind.CONST*/);
-      if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
+      this._eat((91));
+      if (this._peekKind((4)) || this._peekKind((56))) {
         return this.finishListLiteral(start, true, null);
       }
-      else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
-        return this.finishMapLiteral(start, true, null);
+      else if (this._peekKind((6))) {
+        return this.finishMapLiteral(start, true, null, null);
       }
-      else if (this._peekKind(52/*TokenKind.LT*/)) {
+      else if (this._peekKind((52))) {
         return this.finishTypedLiteral(start, true);
       }
       else {
         return this.finishNewExpression(start, true);
       }
 
-    case 104/*TokenKind.NEW*/:
+    case (104):
 
-      this._eat(104/*TokenKind.NEW*/);
+      this._eat((104));
       return this.finishNewExpression(start, false);
 
-    case 2/*TokenKind.LPAREN*/:
+    case (2):
 
       return this._parenOrLambda();
 
-    case 4/*TokenKind.LBRACK*/:
-    case 56/*TokenKind.INDEX*/:
+    case (4):
+    case (56):
 
       return this.finishListLiteral(start, false, null);
 
-    case 6/*TokenKind.LBRACE*/:
+    case (6):
 
-      return this.finishMapLiteral(start, false, null);
+      return this.finishMapLiteral(start, false, null, null);
 
-    case 105/*TokenKind.NULL*/:
+    case (105):
 
-      this._eat(105/*TokenKind.NULL*/);
+      this._eat((105));
       return this._makeLiteral(Value.fromNull(this._makeSpan(start)));
 
-    case 111/*TokenKind.TRUE*/:
+    case (111):
 
-      this._eat(111/*TokenKind.TRUE*/);
+      this._eat((111));
       return this._makeLiteral(Value.fromBool(true, this._makeSpan(start)));
 
-    case 97/*TokenKind.FALSE*/:
+    case (97):
 
-      this._eat(97/*TokenKind.FALSE*/);
+      this._eat((97));
       return this._makeLiteral(Value.fromBool(false, this._makeSpan(start)));
 
-    case 61/*TokenKind.HEX_INTEGER*/:
+    case (61):
 
       var t = this._lang_next();
       return this._makeLiteral(Value.fromInt(t.get$value(), t.get$span()));
 
-    case 60/*TokenKind.INTEGER*/:
+    case (60):
 
       var t = this._lang_next();
       return this._makeLiteral(Value.fromInt(Math.parseInt(t.get$text()), t.get$span()));
 
-    case 62/*TokenKind.DOUBLE*/:
+    case (62):
 
       var t = this._lang_next();
       return this._makeLiteral(Value.fromDouble(Math.parseDouble(t.get$text()), t.get$span()));
 
-    case 58/*TokenKind.STRING*/:
+    case (58):
 
       var t = this._lang_next();
       return this._makeLiteral(Value.fromString(t.get$value(), t.get$span()));
 
-    case 59/*TokenKind.STRING_PART*/:
+    case (59):
 
       return this.stringInterpolation();
 
-    case 52/*TokenKind.LT*/:
+    case (52):
 
       return this.finishTypedLiteral(start, false);
 
-    case 114/*TokenKind.VOID*/:
-    case 113/*TokenKind.VAR*/:
-    case 98/*TokenKind.FINAL*/:
+    case (114):
+    case (113):
+    case (98):
 
       return this.declaredIdentifier(false);
 
     default:
 
       if (!this._peekIdentifier()) {
         this._errorExpected("expression");
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var pieces = new Array();
   var startQuote = null, endQuote = null;
-  while (this._peekKind(59/*TokenKind.STRING_PART*/)) {
+  while (this._peekKind((59))) {
     var token = this._lang_next();
     pieces.add$1(this._makeLiteral(Value.fromString(token.get$value(), token.get$span())));
-    if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
+    if (this._maybeEat((6))) {
       pieces.add$1(this.expression());
-      this._eat(7/*TokenKind.RBRACE*/);
+      this._eat((7));
     }
-    else if (this._maybeEat(109/*TokenKind.THIS*/)) {
+    else if (this._maybeEat((109))) {
       pieces.add$1(new ThisExpression(this._previousToken.get$span()));
     }
     else {
       var id = this.identifier();
       pieces.add$1(new VarExpression(id, id.get$span()));
     }
   }
   var tok = this._lang_next();
-  if ($ne(tok.get$kind(), 58/*TokenKind.STRING*/)) {
+  if ($ne(tok.get$kind(), (58))) {
     this._errorExpected("interpolated string");
   }
   pieces.add$1(this._makeLiteral(Value.fromString(tok.get$value(), tok.get$span())));
   var span = this._makeSpan(start);
   return new StringInterpExpression(pieces, span);
 }
 Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
-  if ($eq(kind, 58/*TokenKind.STRING*/)) {
+  if ($eq(kind, (58))) {
     var t = this._lang_next();
     return t.get$value();
   }
-  else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
+  else if ($eq(kind, (59))) {
     this._lang_next();
     this._errorExpected("string literal, but found interpolated string start");
   }
   return null;
 }
 Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
     var func = new FunctionDefinition(null, null, null, formals, null, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._eatLeftParen();
     var saved = this._inhibitLambda;
     this._inhibitLambda = false;
     var expr = this.expression();
-    this._eat(3/*TokenKind.RPAREN*/);
+    this._eat((3));
     this._inhibitLambda = saved;
     return new ParenExpression(expr, this._makeSpan(start));
   }
 }
 Parser.prototype._atClosureParameters = function() {
   if (this._inhibitLambda) return false;
   var after = this._peekAfterCloseParen();
-  return after.kind == 9/*TokenKind.ARROW*/ || after.kind == 6/*TokenKind.LBRACE*/;
+  return after.kind == (9) || after.kind == (6);
 }
 Parser.prototype._eatLeftParen = function() {
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eat((2));
   this._afterParensIndex++;
 }
 Parser.prototype._peekAfterCloseParen = function() {
   if (this._afterParensIndex < this._afterParens.get$length()) {
     return this._afterParens.$index(this._afterParensIndex);
   }
-  this._afterParensIndex = 0;
+  this._afterParensIndex = (0);
   this._afterParens.clear();
   var tokens = [this._lang_next()];
   this._lookaheadAfterParens(tokens);
   var after = this._peekToken;
   tokens.add$1(after);
   this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
   this._lang_next();
   return after;
 }
 Parser.prototype._lookaheadAfterParens = function(tokens) {
   var saved = this._afterParens.get$length();
   this._afterParens.add(null);
   while (true) {
     var token = this._lang_next();
     tokens.add(token);
     var kind = token.kind;
-    if (kind == 3/*TokenKind.RPAREN*/ || kind == 1/*TokenKind.END_OF_FILE*/) {
+    if (kind == (3) || kind == (1)) {
       this._afterParens.$setindex(saved, this._peekToken);
       return;
     }
-    else if (kind == 2/*TokenKind.LPAREN*/) {
+    else if (kind == (2)) {
       this._lookaheadAfterParens(tokens);
     }
   }
 }
 Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
 Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
-    case 15/*TokenKind.ELLIPSIS*/:
+    case (15):
 
-      this._eat(15/*TokenKind.ELLIPSIS*/);
+      this._eat((15));
       this._lang_error("rest no longer supported", this._previousToken.get$span());
       name = this.identifier().get$name();
       break;
 
-    case 109/*TokenKind.THIS*/:
+    case (109):
 
-      this._eat(109/*TokenKind.THIS*/);
-      this._eat(14/*TokenKind.DOT*/);
+      this._eat((109));
+      this._eat((14));
       name = ("this." + this.identifier().get$name());
       break;
 
-    case 74/*TokenKind.GET*/:
+    case (74):
 
       if (!includeOperators) return null;
-      this._eat(74/*TokenKind.GET*/);
+      this._eat((74));
       if (this._peekIdentifier()) {
         name = ("get:" + this.identifier().get$name());
       }
       else {
         name = "get";
       }
       break;
 
-    case 82/*TokenKind.SET*/:
+    case (82):
 
       if (!includeOperators) return null;
-      this._eat(82/*TokenKind.SET*/);
+      this._eat((82));
       if (this._peekIdentifier()) {
         name = ("set:" + this.identifier().get$name());
       }
       else {
         name = "set";
       }
       break;
 
-    case 81/*TokenKind.OPERATOR*/:
+    case (81):
 
       if (!includeOperators) return null;
-      this._eat(81/*TokenKind.OPERATOR*/);
+      this._eat((81));
       var kind = this._peek();
-      if ($eq(kind, 80/*TokenKind.NEGATE*/)) {
+      if ($eq(kind, (80))) {
         name = ":negate";
         this._lang_next();
       }
       else {
         name = TokenKind.binaryMethodName(kind);
         if (name == null) {
           name = "operator";
         }
         else {
           this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
   return new Identifier(name, this._makeSpan(start));
 }
 Parser.prototype.declaredIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var myType = null;
   var name = this._specialIdentifier(includeOperators);
   if (name == null) {
-    myType = this.type(0);
+    myType = this.type((0));
     name = this._specialIdentifier(includeOperators);
     if (name == null) {
       if (this._peekIdentifier()) {
         name = this.identifier();
       }
       else if ((myType instanceof NameTypeReference) && myType.get$names() == null) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
 Parser.prototype.finishNewExpression = function(start, isConst) {
-  var type = this.type(0);
+  var type = this.type((0));
   var name = null;
-  if (this._maybeEat(14/*TokenKind.DOT*/)) {
+  if (this._maybeEat((14))) {
     name = this.identifier();
   }
   var args = this.arguments();
   return new NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
-Parser.prototype.finishListLiteral = function(start, isConst, type) {
-  if (this._maybeEat(56/*TokenKind.INDEX*/)) {
-    return new ListExpression(isConst, type, [], this._makeSpan(start));
+Parser.prototype.finishListLiteral = function(start, isConst, itemType) {
+  if (this._maybeEat((56))) {
+    return new ListExpression(isConst, itemType, [], this._makeSpan(start));
   }
   var values = [];
-  this._eat(4/*TokenKind.LBRACK*/);
-  while (!this._maybeEat(5/*TokenKind.RBRACK*/)) {
+  this._eat((4));
+  while (!this._maybeEat((5))) {
     values.add$1(this.expression());
-    if (this._recover && !this._recoverTo(5/*TokenKind.RBRACK*/, 11/*TokenKind.COMMA*/)) break;
-    if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
-      this._eat(5/*TokenKind.RBRACK*/);
+    if (this._recover && !this._recoverTo((5), (11))) break;
+    if (!this._maybeEat((11))) {
+      this._eat((5));
       break;
     }
   }
-  return new ListExpression(isConst, type, values, this._makeSpan(start));
+  return new ListExpression(isConst, itemType, values, this._makeSpan(start));
 }
-Parser.prototype.finishMapLiteral = function(start, isConst, type) {
+Parser.prototype.finishMapLiteral = function(start, isConst, keyType, valueType) {
   var items = [];
-  this._eat(6/*TokenKind.LBRACE*/);
-  while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
+  this._eat((6));
+  while (!this._maybeEat((7))) {
     items.add$1(this.expression());
-    this._eat(8/*TokenKind.COLON*/);
+    this._eat((8));
     items.add$1(this.expression());
-    if (this._recover && !this._recoverTo(7/*TokenKind.RBRACE*/, 11/*TokenKind.COMMA*/)) break;
-    if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
-      this._eat(7/*TokenKind.RBRACE*/);
+    if (this._recover && !this._recoverTo((7), (11))) break;
+    if (!this._maybeEat((11))) {
+      this._eat((7));
       break;
     }
   }
-  return new MapExpression(isConst, type, items, this._makeSpan(start));
+  return new MapExpression(isConst, keyType, valueType, items, this._makeSpan(start));
 }
 Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
-  var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
-  if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
-    genericType.set$baseType(new TypeReference(span, $globals.world.listType));
-    return this.finishListLiteral(start, isConst, genericType);
+  var genericType = this.addTypeArguments(typeToBeNamedLater, (0));
+  var typeArgs = genericType.get$typeArguments();
+  if (this._peekKind((4)) || this._peekKind((56))) {
+    if ($ne(typeArgs.get$length(), (1))) {
+      $globals.world.error("exactly one type argument expected for list", genericType.get$span());
+    }
+    return this.finishListLiteral(start, isConst, typeArgs.$index((0)));
   }
-  else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
-    genericType.set$baseType(new TypeReference(span, $globals.world.mapType));
-    var typeArgs = genericType.get$typeArguments();
-    if ($eq(typeArgs.get$length(), 1)) {
-      genericType.set$typeArguments([new TypeReference(span, $globals.world.stringType), typeArgs.$index(0)]);
+  else if (this._peekKind((6))) {
+    var keyType, valueType;
+    if ($eq(typeArgs.get$length(), (1))) {
+      keyType = null;
+      valueType = typeArgs.$index((0));
     }
-    else if ($eq(typeArgs.get$length(), 2)) {
-      var keyType = typeArgs.$index(0);
-      if (!(keyType instanceof NameTypeReference) || $ne(keyType.get$name().get$name(), "String")) {
-        $globals.world.error("the key type of a map literal is implicitly \"String\"", keyType.get$span());
-      }
-      else {
-        $globals.world.warning("a map literal takes one type argument specifying the value type", keyType.get$span());
-      }
+    else if ($eq(typeArgs.get$length(), (2))) {
+      var keyType0 = typeArgs.$index((0));
+      $globals.world.warning("a map literal takes one type argument specifying the value type", keyType0.get$span());
+      valueType = typeArgs.$index((1));
     }
-    return this.finishMapLiteral(start, isConst, genericType);
+    return this.finishMapLiteral(start, isConst, keyType, valueType);
   }
   else {
     this._errorExpected("array or map literal");
   }
 }
 Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
-      case 84/*TokenKind.STATIC*/:
-      case 98/*TokenKind.FINAL*/:
-      case 91/*TokenKind.CONST*/:
-      case 71/*TokenKind.ABSTRACT*/:
-      case 73/*TokenKind.FACTORY*/:
+      case (84):
+      case (98):
+      case (91):
+      case (71):
+      case (73):
 
         if (modifiers == null) modifiers = [];
         modifiers.add$1(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
 Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
-  if (this._maybeEat(96/*TokenKind.EXTENDS*/)) {
-    myType = this.type(1);
+  if (this._maybeEat((96))) {
+    myType = this.type((1));
   }
   var tp = new TypeParameter(name, myType, this._makeSpan(start));
   return new ParameterType(name.get$name(), tp);
 }
 Parser.prototype.get$typeParameter = function() {
   return this.typeParameter.bind(this);
 }
 Parser.prototype.typeParameters = function() {
-  this._eat(52/*TokenKind.LT*/);
+  this._eat((52));
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add$1(tp);
-    if ((tp.get$typeParameter().get$extendsType() instanceof GenericTypeReference) && $eq(tp.get$typeParameter().get$extendsType().get$depth(), 0)) {
+    if ((tp.get$typeParameter().get$extendsType() instanceof GenericTypeReference) && $eq(tp.get$typeParameter().get$extendsType().get$depth(), (0))) {
       closed = true;
       break;
     }
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
+  while (this._maybeEat((11)))
   if (!closed) {
-    this._eat(53/*TokenKind.GT*/);
+    this._eat((53));
   }
   return ret;
 }
 Parser.prototype.get$typeParameters = function() {
   return this.typeParameters.bind(this);
 }
 Parser.prototype._eatClosingAngle = function(depth) {
-  if (this._maybeEat(53/*TokenKind.GT*/)) {
+  if (this._maybeEat((53))) {
     return depth;
   }
-  else if (depth > 0 && this._maybeEat(40/*TokenKind.SAR*/)) {
-    return depth - 1;
+  else if (depth > (0) && this._maybeEat((40))) {
+    return depth - (1);
   }
-  else if (depth > 1 && this._maybeEat(41/*TokenKind.SHR*/)) {
-    return depth - 2;
+  else if (depth > (1) && this._maybeEat((41))) {
+    return depth - (2);
   }
   else {
     this._errorExpected(">");
     return depth;
   }
 }
 Parser.prototype.addTypeArguments = function(baseType, depth) {
-  this._eat(52/*TokenKind.LT*/);
+  this._eat((52));
   return this._finishTypeArguments(baseType, depth, []);
 }
 Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
-  var delta = -1;
+  var delta = (-1);
   do {
-    var myType = this.type(depth + 1);
+    var myType = this.type(depth + (1));
     types.add$1(myType);
     if ((myType instanceof GenericTypeReference) && myType.get$depth() <= depth) {
       delta = depth - myType.get$depth();
       break;
     }
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
-  if (delta >= 0) {
+  while (this._maybeEat((11)))
+  if (delta >= (0)) {
     depth = depth - delta;
   }
   else {
     depth = this._eatClosingAngle(depth);
   }
   var span = this._makeSpan(baseType.span.start);
   return new GenericTypeReference(baseType, types, depth, span);
 }
 Parser.prototype.typeList = function() {
   var types = [];
   do {
-    types.add$1(this.type(0));
+    types.add$1(this.type((0)));
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
+  while (this._maybeEat((11)))
   return types;
 }
 Parser.prototype.nameTypeReference = function() {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
-    case 114/*TokenKind.VOID*/:
+    case (114):
 
       return new TypeReference(this._lang_next().get$span(), $globals.world.voidType);
 
-    case 113/*TokenKind.VAR*/:
+    case (113):
 
       return new TypeReference(this._lang_next().get$span(), $globals.world.varType);
 
-    case 98/*TokenKind.FINAL*/:
+    case (98):
 
-      this._eat(98/*TokenKind.FINAL*/);
+      this._eat((98));
       isFinal = true;
       name = this.identifier();
       break;
 
     default:
 
       name = this.identifier();
       break;
 
   }
-  while (this._maybeEat(14/*TokenKind.DOT*/)) {
+  while (this._maybeEat((14))) {
     if (names == null) names = [];
     names.add$1(this.identifier());
   }
   return new NameTypeReference(isFinal, name, names, this._makeSpan(start));
 }
 Parser.prototype.type = function(depth) {
   var typeRef = this.nameTypeReference();
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if (this._peekKind((52))) {
     return this.addTypeArguments(typeRef, depth);
   }
   else {
     return typeRef;
   }
 }
-Parser.prototype.type.$optional = ['depth', '0']
+Parser.prototype.type.$optional = ['depth', '(0)']
 Parser.prototype.get$type = function() {
   return this.type.bind(this);
 }
 Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.get$type();
   var name = di.get$name();
   if (name == null) {
     this._lang_error("Formal parameter invalid", this._makeSpan(start));
   }
   var value = null;
-  if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+  if (this._maybeEat((20))) {
     if (!inOptionalBlock) {
       this._lang_error("default values only allowed inside [optional] section");
     }
     value = this.expression();
   }
-  else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
+  else if (this._peekKind((2))) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = this._makeLiteral(Value.fromNull(this._makeSpan(start)));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 Parser.prototype.formalParameterList = function() {
   this._eatLeftParen();
   var formals = [];
   var inOptionalBlock = false;
-  if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
-    if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
+  if (!this._maybeEat((3))) {
+    if (this._maybeEat((4))) {
       inOptionalBlock = true;
     }
     formals.add$1(this.formalParameter(inOptionalBlock));
-    while (this._maybeEat(11/*TokenKind.COMMA*/)) {
-      if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
+    while (this._maybeEat((11))) {
+      if (this._maybeEat((4))) {
         if (inOptionalBlock) {
           this._lang_error("already inside an optional block", this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add$1(this.formalParameter(inOptionalBlock));
     }
     if (inOptionalBlock) {
-      this._eat(5/*TokenKind.RBRACK*/);
+      this._eat((5));
     }
-    this._eat(3/*TokenKind.RPAREN*/);
+    this._eat((3));
   }
   return formals;
 }
 Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!this._isIdentifier(tok.get$kind())) {
     this._lang_error(("expected identifier, but found " + tok), tok.get$span());
   }
   return new Identifier(tok.get$text(), this._makeSpan(tok.get$start()));
 }
@@ skipping 41 matching lines @@
   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._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;
@@ skipping 116 matching lines @@
   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.get$values = function() { return this.values; };
-VariableDefinition.prototype.set$values = function(value) { return this.values = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 VariableDefinition.prototype.visit$1 = VariableDefinition.prototype.visit;
 // ********** Code for FunctionDefinition **************
 $inherits(FunctionDefinition, Definition);
 function FunctionDefinition(modifiers, returnType, name, formals, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
@@ skipping 355 matching lines @@
 NewExpression.prototype.get$name = function() { return this.name; };
 NewExpression.prototype.set$name = function(value) { return this.name = value; };
 NewExpression.prototype.get$arguments = function() { return this.arguments; };
 NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 NewExpression.prototype.visit$1 = NewExpression.prototype.visit;
 // ********** Code for ListExpression **************
 $inherits(ListExpression, Expression);
-function ListExpression(isConst, type, values, span) {
+function ListExpression(isConst, itemType, values, span) {
   this.isConst = isConst;
-  this.type = type;
+  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.get$type = function() { return this.type; };
-ListExpression.prototype.set$type = function(value) { return this.type = value; };
-ListExpression.prototype.get$values = function() { return this.values; };
-ListExpression.prototype.set$values = function(value) { return this.values = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 ListExpression.prototype.visit$1 = ListExpression.prototype.visit;
 // ********** Code for MapExpression **************
 $inherits(MapExpression, Expression);
-function MapExpression(isConst, type, items, span) {
+function MapExpression(isConst, keyType, valueType, items, span) {
   this.isConst = isConst;
-  this.type = type;
+  this.keyType = keyType;
+  this.valueType = valueType;
   this.items = items;
   // Initializers done
   Expression.call(this, span);
 }
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
-MapExpression.prototype.get$type = function() { return this.type; };
-MapExpression.prototype.set$type = function(value) { return this.type = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 MapExpression.prototype.visit$1 = MapExpression.prototype.visit;
 // ********** Code for ConditionalExpression **************
 $inherits(ConditionalExpression, Expression);
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
@@ skipping 358 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 113 matching lines @@
 Type.prototype._getMemberInParents = function(memberName) {
   if (this.get$isClass()) {
     if (this.get$parent() != null) {
       return this.get$parent().getMember(memberName);
     }
     else {
       return null;
     }
   }
   else {
-    if (this.get$interfaces() != null && this.get$interfaces().get$length() > 0) {
+    if (this.get$interfaces() != null && this.get$interfaces().get$length() > (0)) {
       var $$list = this.get$interfaces();
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
         var i = $$list.$index($$i);
         var ret = i.getMember$1(memberName);
         if (ret != null) {
           return ret;
         }
       }
     }
     return $globals.world.objectType.getMember(memberName);
@@ skipping 10 matching lines @@
   this._resolvedMembers.$setindex(memberName, ret);
   if (member.get$isStatic()) {
     return ret;
   }
   else {
     var $$list = this.get$subtypes();
     for (var $$i = this.get$subtypes().iterator(); $$i.hasNext$0(); ) {
       var t = $$i.next$0();
       if (!this.get$isClass() && t.get$isClass()) {
         var m = t.getMember$1(memberName);
-        if (m != null && ret.members.indexOf(m) == -1) {
+        if (m != null && ret.members.indexOf(m) == (-1)) {
           ret.add(m);
         }
       }
       else {
         var m = t.get$members().$index(memberName);
         if (m != null) ret.add(m);
       }
     }
     return ret;
   }
@@ skipping 73 matching lines @@
   }
   if (this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf$1(other);
   })
   )) {
     return true;
   }
   return false;
 }
 Type.prototype.hashCode = function() {
-  var libraryCode = this.get$library() == null ? 1 : this.get$library().hashCode();
-  var nameCode = this.name == null ? 1 : this.name.hashCode();
-  return (libraryCode << 4) ^ nameCode;
+  var libraryCode = this.get$library() == null ? (1) : this.get$library().hashCode();
+  var nameCode = this.name == null ? (1) : this.name.hashCode();
+  return (libraryCode << (4)) ^ nameCode;
 }
 Type.prototype.$eq = function(other) {
   return (other instanceof Type) && $eq(other.get$name(), this.name) && $eq(this.get$library(), other.get$library());
 }
 Type._isFunctionSubtypeOf = function(t, s) {
   if (!s.returnType.get$isVoid() && !s.returnType.isAssignable(t.returnType)) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
   if (tp.get$length() < sp.get$length()) return false;
-  for (var i = 0;
+  for (var i = (0);
    i < sp.get$length(); i++) {
     if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
     if (tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name())) return false;
     if (!tp.$index(i).get$type().isAssignable$1(sp.$index(i).get$type())) return false;
   }
   if (tp.get$length() > sp.get$length() && !tp.$index(sp.get$length()).get$isOptional()) return false;
   return true;
 }
 Type.prototype._checkExtends$0 = Type.prototype._checkExtends;
 Type.prototype.addDirectSubtype$1 = Type.prototype.addDirectSubtype;
@@ skipping 448 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 43 matching lines @@
       this._subtypes.addAll(st.get$subtypes());
     }
   }
   return this._subtypes;
 }
 DefinedType.prototype._cycleInClassExtends = function() {
   var seen = new HashSetImplementation();
   seen.add(this);
   var ancestor = this.get$parent();
   while (ancestor != null) {
-    if (ancestor === this) {
+    if (ancestor == this) {
       return true;
     }
     if (seen.contains(ancestor)) {
       return false;
     }
     seen.add(ancestor);
     ancestor = ancestor.get$parent();
   }
   return false;
 }
 DefinedType.prototype._cycleInInterfaceExtends = function() {
   var $this = this; // closure support
   var seen = new HashSetImplementation();
   seen.add(this);
   function _helper(ancestor) {
     if (ancestor == null) return false;
-    if (ancestor === $this) return true;
+    if (ancestor == $this) return true;
     if (seen.contains(ancestor)) {
       return false;
     }
     seen.add(ancestor);
     if (ancestor.get$interfaces() != null) {
       var $$list = ancestor.get$interfaces();
       for (var $$i = ancestor.get$interfaces().iterator$0(); $$i.hasNext$0(); ) {
         var parent = $$i.next$0();
         if (_helper(parent)) return true;
       }
     }
     return false;
   }
-  for (var i = 0;
+  for (var i = (0);
    i < this.interfaces.get$length(); i++) {
     if (_helper(this.interfaces.$index(i))) return i;
   }
-  return -1;
+  return (-1);
 }
 DefinedType.prototype.resolve = function() {
   if ((this.definition instanceof TypeDefinition)) {
     var typeDef = this.definition;
     if (this.isClass) {
-      if (typeDef.extendsTypes != null && typeDef.extendsTypes.get$length() > 0) {
-        if (typeDef.extendsTypes.get$length() > 1) {
-          $globals.world.error("more than one base class", typeDef.extendsTypes.$index(1).get$span());
+      if (typeDef.extendsTypes != null && typeDef.extendsTypes.get$length() > (0)) {
+        if (typeDef.extendsTypes.get$length() > (1)) {
+          $globals.world.error("more than one base class", typeDef.extendsTypes.$index((1)).get$span());
         }
-        var extendsTypeRef = typeDef.extendsTypes.$index(0);
+        var extendsTypeRef = typeDef.extendsTypes.$index((0));
         if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = extendsTypeRef;
           this.set$parent(this.resolveType(g.baseType, true));
         }
         this.set$parent(this.resolveType(extendsTypeRef, true));
         if (!this.get$parent().get$isClass()) {
-          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes.$index(0).get$span());
+          $globals.world.error("class may not extend an interface - use implements", typeDef.extendsTypes.$index((0)).get$span());
         }
         this.get$parent().addDirectSubtype(this);
         if (this._cycleInClassExtends()) {
           $globals.world.error(("class \"" + this.name + "\" has a cycle in its inheritance chain"), extendsTypeRef.get$span());
         }
       }
       else {
         if (!this.get$isObject()) {
           this.set$parent($globals.world.objectType);
           this.get$parent().addDirectSubtype(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if (typeDef.defaultType != null) {
         $globals.world.error("default not allowed on classes", typeDef.defaultType.span);
       }
     }
     else {
-      if (typeDef.implementsTypes != null && typeDef.implementsTypes.get$length() > 0) {
-        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes.$index(0).get$span());
+      if (typeDef.implementsTypes != null && typeDef.implementsTypes.get$length() > (0)) {
+        $globals.world.error("implements not allowed on interfaces (use extends)", typeDef.implementsTypes.$index((0)).get$span());
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
-      if (res >= 0) {
+      if (res >= (0)) {
         $globals.world.error(("interface \"" + this.name + "\" has a cycle in its inheritance chain"), typeDef.extendsTypes.$index(res).get$span());
       }
       if (typeDef.defaultType != null) {
         this.defaultType = this.resolveType(typeDef.defaultType.baseType, true);
         if (this.defaultType == null) {
           $globals.world.warning("unresolved default class", typeDef.defaultType.span);
         }
         else {
           this.defaultType._resolveTypeParams(typeDef.defaultType.typeParameters);
         }
@@ skipping 40 matching lines @@
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(("duplicate constructor definition of " + method.get$name()), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition.modifiers != null && definition.modifiers.get$length() == 1 && $eq(definition.modifiers.$index(0).get$kind(), 73/*TokenKind.FACTORY*/)) {
+  if (definition.modifiers != null && definition.modifiers.get$length() == (1) && $eq(definition.modifiers.$index((0)).get$kind(), (73))) {
     if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
       $globals.world.error(("duplicate factory definition of \"" + method.get$name() + "\""), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
     return;
   }
   if (methodName.startsWith("get:") || methodName.startsWith("set:")) {
-    var propName = methodName.substring(4);
+    var propName = methodName.substring((4));
     var prop = this.members.$index(propName);
     if (prop == null) {
       prop = new PropertyMember(propName, this);
       this.members.$setindex(propName, prop);
     }
     if (!(prop instanceof PropertyMember)) {
       $globals.world.error(("property conflicts with field \"" + propName + "\""), definition.span);
       return;
     }
-    if (methodName[0] == "g") {
+    if (methodName[(0)] == "g") {
       if (prop.get$getter() != null) {
         $globals.world.error(("duplicate getter definition for \"" + propName + "\""), definition.span);
       }
       prop.set$getter(method);
     }
     else {
       if (prop.get$setter() != null) {
         $globals.world.error(("duplicate setter definition for \"" + propName + "\""), definition.span);
       }
       prop.set$setter(method);
     }
     return;
   }
   if (this.members.containsKey(methodName)) {
     $globals.world.error(("duplicate method definition of \"" + method.get$name() + "\""), definition.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition) {
-  for (var i = 0;
+  for (var i = (0);
    i < definition.names.get$length(); i++) {
     var name = definition.names.$index(i).get$name();
     if (this.members.containsKey(name)) {
       $globals.world.error(("duplicate field definition of \"" + name + "\""), definition.span);
       return;
     }
     var value = null;
     if (definition.values != null) {
       value = definition.values.$index(i);
     }
@@ skipping 21 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/*const []*/);
+    return (list != null ? list : const$127);
   }
   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());
     return;
   }
-  for (var i = 0;
+  for (var i = (0);
    i < interfaceParams.get$length(); i++) {
     var ip = interfaceParams.$index(i);
     var dp = defaultParams.$index(i);
     var cp = classParams.$index(i);
     dp.resolve$0();
     if ($ne(ip.get$name(), dp.get$name()) || $ne(dp.get$name(), cp.get$name())) {
       $globals.world.error("default class must have the same type parameter names as the class and interface", ip.get$span(), dp.get$span(), cp.get$span());
     }
     else if ($ne(dp.get$extendsType(), cp.get$extendsType())) {
       $globals.world.error("default class type parameters must have the same extends as the class does", dp.get$span(), cp.get$span());
     }
     else if (!dp.get$extendsType().isSubtypeOf$1(ip.get$extendsType())) {
       $globals.world.warning("\"default\" can only have tighter type parameter \"extends\" than the interface", dp.get$span(), ip.get$span());
     }
   }
 }
 DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
-  if (name == "" && this.definition != null && this.isClass && this.constructors.get$length() == 0) {
+  if (name == "" && this.definition != null && this.isClass && this.constructors.get$length() == (0)) {
     var span = this.definition.span;
     var inits = null, native_ = null, body = null;
     if (this.isNative) {
       native_ = "";
       inits = null;
     }
     else {
       body = null;
       inits = [new CallExpression(new SuperExpression(span), [], span)];
     }
@@ skipping 19 matching lines @@
   }
   return this._getMemberInParents(memberName);
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
   var jsnames = [];
   var names = [];
   var typeMap = new HashMapImplementation();
-  for (var i = 0;
+  for (var i = (0);
    i < typeArgs.get$length(); i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
     jsnames.add$1(typeArgs.$index(i).get$jsname());
   }
   var jsname = ("" + this.get$jsname() + "_" + Strings.join(jsnames, "$"));
   var simpleName = ("" + this.name + "<" + Strings.join(names, ", ") + ">");
   var key = Strings.join(names, "$");
   var ret = this._concreteTypes.$index(key);
@@ skipping 25 matching lines @@
 DefinedType.prototype.setDefinition$1 = DefinedType.prototype.setDefinition;
 // ********** Code for NativeType **************
 function NativeType(name) {
   this.isConstructorHidden = false
   this.isJsGlobalObject = false
   this.isSingleton = false
   this.name = name;
   // Initializers done
   while (true) {
     if (this.name.startsWith("@")) {
-      this.name = this.name.substring(1);
+      this.name = this.name.substring((1));
       this.isJsGlobalObject = true;
     }
     else if (this.name.startsWith("*")) {
-      this.name = this.name.substring(1);
+      this.name = this.name.substring((1));
       this.isConstructorHidden = true;
     }
     else {
       break;
     }
   }
   if (this.name.startsWith("=")) {
-    this.name = this.name.substring(1);
+    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.value = value;
   this.length = length;
   // Initializers done
 }
 FixedCollection.prototype.get$value = function() { return this.value; };
 FixedCollection.prototype.get$length = function() { return this.length; };
 FixedCollection.prototype.iterator = function() {
   return new FixedIterator_E(this.value, this.length);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new Array(), f);
 }
 FixedCollection.prototype.every = function(f) {
   return Collections.every(this, f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
-  return this.length == 0;
+  return this.length == (0);
 }
 FixedCollection.prototype.every$1 = function($0) {
   return this.every(to$call$1($0));
 };
 FixedCollection.prototype.filter$1 = function($0) {
   return this.filter(to$call$1($0));
 };
 FixedCollection.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 FixedCollection.prototype.isEmpty$0 = FixedCollection.prototype.isEmpty;
 FixedCollection.prototype.iterator$0 = FixedCollection.prototype.iterator;
 FixedCollection.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for FixedCollection_Type **************
 $inherits(FixedCollection_Type, FixedCollection);
 function FixedCollection_Type(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
-  this._index = 0
+  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
@@ skipping 39 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$canonicalCode = function() {
-  return null;
-}
 Value.prototype.get$constValue = function() {
   return null;
 }
 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.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):
+
+      return new Value($globals.world.nonNullBool, ("" + this.get$code() + " == " + other.get$code()), node.get$span(), true);
+
+    case (51):
+
+      return new Value($globals.world.nonNullBool, ("" + this.get$code() + " != " + other.get$code()), node.get$span(), true);
+
+  }
+  var name = kind == (49) ? ":ne" : TokenKind.binaryMethodName(kind);
+  return this.invoke(context, name, node, new Arguments(null, [other]), false);
+}
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if (name == ":call") {
     if (this.isType) {
       $globals.world.error("must use \"new\" or \"const\" to construct a new instance", node.span);
     }
     if (this.get$type().needsVarCall(args)) {
       return this._varCall(context, node, args);
     }
   }
   var member = this._resolveMember(context, name, node, isDynamic);
@@ skipping 11 matching lines @@
   var member = this._resolveMember(context, name, null, true);
   return member != null && member.canInvoke$2(context, args);
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
   if (this.isSuper) {
     var m = this.get$type().getMember("noSuchMethod");
     return m != null && !m.get$declaringType().get$isObject();
   }
   else {
     var m = this.get$type().resolveMember("noSuchMethod");
-    return m != null && m.get$members().get$length() > 1;
+    return m != null && m.get$members().get$length() > (1);
   }
 }
 Value.prototype._tryResolveMember = function(context, name) {
   if (this.isSuper) {
     return this.get$type().getMember(name);
   }
   else {
     return this.get$type().resolveMember(name);
   }
 }
@@ skipping 45 matching lines @@
 Value.prototype.convertTo = function(context, toType, isDynamic) {
   var checked = !isDynamic;
   var callMethod = toType.getCallMethod();
   if (callMethod != null) {
     if (checked && !toType.isAssignable(this.get$type())) {
       this.convertWarning(toType);
     }
     return this._maybeWrapFunction(toType, callMethod);
   }
   var fromType = this.get$type();
-  if (this.get$type().get$isVar() && (this.code != "null" || !toType.get$isNullable())) {
+  if (this.get$type().get$isVar() && (this.get$code() != "null" || !toType.get$isNullable())) {
     fromType = $globals.world.objectType;
   }
   var bothNum = this.get$type().get$isNum() && toType.get$isNum();
   if (fromType.isSubtypeOf(toType) || bothNum) {
     return this;
   }
   if (checked && !toType.isSubtypeOf(this.get$type())) {
     this.convertWarning(toType);
   }
   if ($globals.options.enableTypeChecks) {
     if (context == null && isDynamic) {
       return null;
     }
     return this._typeAssert(context, toType, isDynamic);
   }
   else {
     return this;
   }
 }
 Value.prototype._maybeWrapFunction = function(toType, callMethod) {
   var arity = callMethod.parameters.get$length();
   var myCall = this.get$type().getCallMethod();
   var result = this;
   if (myCall == null || $ne(myCall.get$parameters().get$length(), arity)) {
     var stub = $globals.world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
-    result = new Value(toType, ("to$" + stub.name + "(" + this.code + ")"), this.span, true);
+    result = new Value(toType, ("to$" + stub.name + "(" + this.get$code() + ")"), this.span, true);
   }
   if (toType.get$library().get$isDom() && !this.get$type().get$library().get$isDom()) {
-    if (arity == 0) {
+    if (arity == (0)) {
       $globals.world.gen.corejs.useWrap0 = true;
     }
     else {
       $globals.world.gen.corejs.useWrap1 = true;
     }
-    result = new Value(toType, ("$wrap_call$" + arity + "(" + result.code + ")"), this.span, true);
+    result = new Value(toType, ("$wrap_call$" + arity + "(" + result.get$code() + ")"), this.span, true);
   }
   return result;
 }
 Value.prototype._typeAssert = function(context, toType, isDynamic) {
   if ((toType instanceof ParameterType)) {
     var p = toType;
     toType = p.extendsType;
   }
   if (toType.get$isObject() || toType.get$isVar()) {
     $globals.world.internalError(("We thought " + this.get$type().name + " is not a subtype of " + toType.name + "?"));
   }
   function throwTypeError(paramName) {
     return $globals.world.withoutForceDynamic((function () {
       var typeErrorCtor = $globals.world.typeErrorType.getConstructor("_internal");
       $globals.world.gen.corejs.ensureTypeNameOf();
       var result = typeErrorCtor.invoke$5(context, null, new Value.type$ctor($globals.world.typeErrorType, null), new Arguments(null, [new Value($globals.world.objectType, paramName, null, true), new Value($globals.world.stringType, ("\"" + toType.name + "\""), null, true)]), isDynamic);
       $globals.world.gen.corejs.useThrow = true;
       return ("$throw(" + result.get$code() + ")");
     })
     );
   }
   if (toType.get$isNum()) toType = $globals.world.numType;
   var check;
   if (toType.get$isVoid()) {
-    check = ("$assert_void(" + this.code + ")");
+    check = ("$assert_void(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
       toType.typeCheckCode = ("function $assert_void(x) {\n  if (x == null) return null;\n  " + throwTypeError("x") + "\n}");
     }
   }
   else if ($eq(toType, $globals.world.nonNullBool)) {
     $globals.world.gen.corejs.useNotNullBool = true;
-    check = ("$notnull_bool(" + this.code + ")");
+    check = ("$notnull_bool(" + this.get$code() + ")");
   }
   else if (toType.get$library().get$isCore() && toType.get$typeofName() != null) {
-    check = ("$assert_" + toType.name + "(" + this.code + ")");
+    check = ("$assert_" + toType.name + "(" + this.get$code() + ")");
     if (toType.typeCheckCode == null) {
       toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  " + throwTypeError("x") + "\n}");
     }
   }
   else {
     toType.isChecked = true;
     var checkName = "assert$" + toType.get$jsname();
     var temp = context.getTemp(this);
-    check = ("(" + context.assignTemp(temp, this).code + " == null ? null :");
+    check = ("(" + context.assignTemp(temp, this).get$code() + " == null ? null :");
     check = check + (" " + temp.get$code() + "." + checkName + "())");
     if ($ne(this, temp)) context.freeTemp(temp);
     $globals.world.objectType.varStubs.putIfAbsent(checkName, (function () {
       return new VarMethodStub(checkName, null, Arguments.get$EMPTY(), throwTypeError("this"));
     })
     );
   }
   return new Value(toType, check, this.span, true);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if (toType.get$isVar()) {
     $globals.world.error("can not resolve type", span);
   }
   var testCode = null;
   if (toType.get$isVar() || toType.get$isObject() || (toType instanceof ParameterType)) {
     if (this.needsTemp) {
-      return new Value($globals.world.nonNullBool, ("(" + this.code + ", true)"), span, true);
+      return new Value($globals.world.nonNullBool, ("(" + this.get$code() + ", true)"), span, true);
     }
     else {
-      return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, true, "true", null);
+      return Value.fromBool(true, span);
     }
   }
   if (toType.get$library().get$isCore()) {
     var typeofName = toType.get$typeofName();
     if (typeofName != null) {
-      testCode = ("(typeof(" + this.code + ") " + (isTrue ? "==" : "!=") + " '" + typeofName + "')");
+      testCode = ("(typeof(" + this.get$code() + ") " + (isTrue ? "==" : "!=") + " '" + typeofName + "')");
     }
   }
   if (toType.get$isClass() && !(toType instanceof ConcreteType) && !toType.get$isHiddenNativeType()) {
     toType.markUsed();
-    testCode = ("(" + this.code + " instanceof " + toType.get$jsname() + ")");
+    testCode = ("(" + this.get$code() + " instanceof " + toType.get$jsname() + ")");
     if (!isTrue) {
       testCode = "!" + testCode;
     }
   }
   if (testCode == null) {
     toType.isTested = true;
     var temp = context.getTemp(this);
     var checkName = ("is$" + toType.get$jsname());
-    testCode = ("(" + context.assignTemp(temp, this).code + " &&");
+    testCode = ("(" + context.assignTemp(temp, this).get$code() + " &&");
     testCode = testCode + (" " + temp.get$code() + "." + checkName + "())");
     if (isTrue) {
       testCode = "!!" + testCode;
     }
     else {
       testCode = "!" + testCode;
     }
     if ($ne(this, temp)) context.freeTemp(temp);
     if (!$globals.world.objectType.varStubs.containsKey(checkName)) {
       $globals.world.objectType.varStubs.$setindex(checkName, new VarMethodStub(checkName, null, Arguments.get$EMPTY(), "return false"));
     }
   }
   return new Value($globals.world.nonNullBool, testCode, span, true);
 }
 Value.prototype.convertWarning = function(toType) {
   $globals.world.warning(("type \"" + this.get$type().name + "\" is not assignable to \"" + toType.name + "\""), this.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   var pos = "";
   if (args != null) {
     var argsCode = [];
-    for (var i = 0;
+    for (var i = (0);
      i < args.get$length(); i++) {
       argsCode.add$1(args.values.$index(i).get$code());
     }
     pos = Strings.join(argsCode, ", ");
   }
   var noSuchArgs = [new Value($globals.world.stringType, ("\"" + name + "\""), node.span, true), new Value($globals.world.listType, ("[" + pos + "]"), node.span, true)];
   return this._resolveMember(context, "noSuchMethod", node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
 Value.fromBool = function(value, span) {
-  return EvaluatedValue.EvaluatedValue$factory($globals.world.nonNullBool, value, value.toString(), span);
+  return new BoolValue(value, true, span);
 }
 Value.fromInt = function(value, span) {
-  var strValue = value.toString();
-  return EvaluatedValue.EvaluatedValue$factory($globals.world.numType, value, strValue, span);
+  return new IntValue(value, true, span);
 }
 Value.fromDouble = function(value, span) {
-  var strValue = value.toString();
-  if ($eq(strValue.indexOf$1("."), -1) && $eq(strValue.indexOf$1("e"), -1)) {
-    strValue = strValue + ".0";
-  }
-  return EvaluatedValue.EvaluatedValue$factory($globals.world.numType, value, strValue, span);
+  return new DoubleValue(value, true, span);
 }
 Value.fromString = function(value, span) {
+  return new StringValue(value, true, span);
+}
+Value.fromNull = function(span) {
+  return new NullValue(true, span);
+}
+Value.prototype.binop$4 = Value.prototype.binop;
+Value.prototype.checkFirstClass$1 = Value.prototype.checkFirstClass;
+Value.prototype.convertTo$2 = function($0, $1) {
+  return this.convertTo($0, $1, false);
+};
+Value.prototype.convertTo$3 = Value.prototype.convertTo;
+Value.prototype.get_$3 = Value.prototype.get_;
+Value.prototype.instanceOf$3$isTrue$forceCheck = Value.prototype.instanceOf;
+Value.prototype.instanceOf$4 = function($0, $1, $2, $3) {
+  return this.instanceOf($0, $1, $2, $3, false);
+};
+Value.prototype.invoke$4 = function($0, $1, $2, $3) {
+  return this.invoke($0, $1, $2, $3, false);
+};
+Value.prototype.invoke$4$isDynamic = Value.prototype.invoke;
+Value.prototype.invoke$5 = Value.prototype.invoke;
+Value.prototype.needsConversion$1 = Value.prototype.needsConversion;
+Value.prototype.set_$4 = function($0, $1, $2, $3) {
+  return this.set_($0, $1, $2, $3, false);
+};
+// ********** Code for EvaluatedValue **************
+$inherits(EvaluatedValue, Value);
+function EvaluatedValue(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);
+  switch (kind) {
+    case (50):
+
+      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):
+
+      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);
+}
+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.binop = function(kind, other, context, node) {
+  if (!(other instanceof BoolValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  switch (kind) {
+    case (35):
+
+      return new BoolValue(this.actualValue && other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+    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 Value.prototype.binop.call(this, kind, other, context, node);
+}
+BoolValue.prototype.binop$4 = BoolValue.prototype.binop;
+// ********** 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.binop = function(kind, other, context, node) {
+  if (!(other instanceof IntValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  switch (kind) {
+    case (50):
+
+      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+    case (51):
+
+      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+  }
+  return Value.prototype.binop.call(this, kind, other, context, node);
+}
+IntValue.prototype.binop$4 = IntValue.prototype.binop;
+// ********** 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.binop = function(kind, other, context, node) {
+  if (!(other instanceof DoubleValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  switch (kind) {
+    case (50):
+
+      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+    case (51):
+
+      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+  }
+  return Value.prototype.binop.call(this, kind, other, context, node);
+}
+DoubleValue.prototype.binop$4 = DoubleValue.prototype.binop;
+// ********** 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);
+  switch (kind) {
+    case (50):
+
+      return new BoolValue(this.actualValue == other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+    case (51):
+
+      return new BoolValue(this.actualValue != other.get$actualValue(), this.isConst && other.get$isConst(), node.get$span());
+
+  }
+  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 < value.length; i++) {
-    var ch = value.charCodeAt(i);
+  for (var i = (0);
+   i < this.actualValue.length; i++) {
+    var ch = this.actualValue.charCodeAt(i);
     switch (ch) {
-      case 9:
+      case (9):
 
         buf.add("\\t");
         break;
 
-      case 10:
+      case (10):
 
         buf.add("\\n");
         break;
 
-      case 13:
+      case (13):
 
         buf.add("\\r");
         break;
 
-      case 34:
+      case (34):
 
         buf.add("\\\"");
         break;
 
-      case 92:
+      case (92):
 
         buf.add("\\\\");
         break;
 
       default:
 
-        if (ch >= 32 && ch <= 126) {
-          buf.add(value[i]);
+        if (ch >= (32) && ch <= (126)) {
+          buf.add(this.actualValue[i]);
         }
         else {
-          var hex = ch.toRadixString$1(16);
+          var hex = ch.toRadixString$1((16));
           switch (hex.get$length()) {
-            case 1:
+            case (1):
 
               buf.add("\\x0");
               buf.add(hex);
               break;
 
-            case 2:
+            case (2):
 
               buf.add("\\x");
               buf.add(hex);
               break;
 
-            case 3:
+            case (3):
 
               buf.add("\\u0");
               buf.add(hex);
               break;
 
-            case 4:
+            case (4):
 
               buf.add("\\u");
               buf.add(hex);
               break;
 
             default:
 
               $globals.world.internalError("unicode values greater than 2 bytes not implemented");
               break;
 
           }
         }
         break;
 
     }
   }
   buf.add("\"");
-  return EvaluatedValue.EvaluatedValue$factory($globals.world.stringType, value, buf.toString(), span);
+  return buf.toString();
 }
-Value.fromNull = function(span) {
-  return EvaluatedValue.EvaluatedValue$factory($globals.world.varType, null, "null", span);
-}
-Value.prototype.checkFirstClass$1 = Value.prototype.checkFirstClass;
-Value.prototype.convertTo$2 = function($0, $1) {
-  return this.convertTo($0, $1, false);
-};
-Value.prototype.convertTo$3 = Value.prototype.convertTo;
-Value.prototype.get_$3 = Value.prototype.get_;
-Value.prototype.instanceOf$3$isTrue$forceCheck = Value.prototype.instanceOf;
-Value.prototype.instanceOf$4 = function($0, $1, $2, $3) {
-  return this.instanceOf($0, $1, $2, $3, false);
-};
-Value.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
-};
-Value.prototype.invoke$4$isDynamic = Value.prototype.invoke;
-Value.prototype.invoke$5 = Value.prototype.invoke;
-Value.prototype.needsConversion$1 = Value.prototype.needsConversion;
-Value.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
-};
-// ********** Code for EvaluatedValue **************
-$inherits(EvaluatedValue, Value);
-function EvaluatedValue() {}
-EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, span, code) {
-  this.actualValue = actualValue;
-  this.canonicalCode = canonicalCode;
-  // Initializers done
-  Value.call(this, type, code, span, false);
-}
-EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
-EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
-  return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
-}
-EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
-EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
-EvaluatedValue.prototype.get$isConst = function() {
-  return true;
-}
-EvaluatedValue.prototype.get$constValue = function() {
-  return this;
-}
-EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
-EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
-EvaluatedValue.codeWithComments = function(canonicalCode, span) {
-  return canonicalCode;
-}
-// ********** Code for ConstListValue **************
-$inherits(ConstListValue, EvaluatedValue);
-function ConstListValue() {}
-ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
+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._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
+  EvaluatedValue.call(this, isConst, type, span);
 }
-ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
-ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, span) {
-  return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, 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());
+  }
+  buf.add("]");
+  var listCode = buf.toString();
+  if (!this.isConst) return listCode;
+  var v = new Value($globals.world.listType, listCode, this.span, true);
+  var immutableListCtor = $globals.world.immutableListType.getConstructor("from");
+  var result = immutableListCtor.invoke$4(null, null, new Value.type$ctor(v.get$type(), this.span), new Arguments(null, [v]));
+  return result.get$code();
 }
-ConstListValue.prototype.get$values = function() { return this.values; };
-ConstListValue.prototype.set$values = function(value) { return this.values = value; };
-// ********** Code for ConstMapValue **************
-$inherits(ConstMapValue, EvaluatedValue);
-function ConstMapValue() {}
-ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
+ListValue.prototype.binop = function(kind, other, context, node) {
+  if (!(other instanceof ListValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  switch (kind) {
+    case (50):
+
+      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):
+
+      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);
+}
+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._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
+  EvaluatedValue.call(this, isConst, type, span);
 }
-ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
-ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
-  var values = new HashMapImplementation();
-  for (var i = 0;
-   i < keyValuePairs.get$length(); i += 2) {
-    values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
+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() {
+  return $globals.world.gen.globalForConst(this, this.values);
+}
+MapValue.prototype.binop = function(kind, other, context, node) {
+  if (!(other instanceof MapValue)) return Value.prototype.binop.call(this, kind, other, context, node);
+  switch (kind) {
+    case (50):
+
+      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):
+
+      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 ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
+  return Value.prototype.binop.call(this, kind, other, context, node);
 }
-ConstMapValue.prototype.get$values = function() { return this.values; };
-ConstMapValue.prototype.set$values = function(value) { return this.values = value; };
-// ********** Code for ConstObjectValue **************
-$inherits(ConstObjectValue, EvaluatedValue);
-function ConstObjectValue() {}
-ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
+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
-  EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, span, code);
+  EvaluatedValue.call(this, isConst, type, span);
 }
-ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
-ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, span) {
-  var fieldValues = [];
-  var $$list = fields.getKeys();
-  for (var $$i = fields.getKeys().iterator$0(); $$i.hasNext$0(); ) {
-    var f = $$i.next$0();
-    fieldValues.add(("" + f + " = " + fields.$index(f).get$actualValue()));
+ObjectValue.prototype.get$fields = function() { return this.fields; };
+ObjectValue.prototype.set$fields = function(value) { return this.fields = value; };
+ObjectValue.prototype.get$code = function() {
+  return this._code;
+}
+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):
+
+      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):
+
+      return new BoolValue($ne(this.get$type(), other.get$type()) || this.get$code() != other.get$code(), this.isConst && other.get$isConst(), node.get$span());
+
   }
-  fieldValues.sort((function (a, b) {
-    return a.compareTo$1(b);
-  })
-  );
-  var actualValue = ("const " + type.get$jsname() + " [") + Strings.join(fieldValues, ",") + "]";
-  return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
+  return Value.prototype.binop.call(this, kind, other, context, node);
 }
-ConstObjectValue.prototype.get$fields = function() { return this.fields; };
-ConstObjectValue.prototype.set$fields = function(value) { return this.fields = value; };
+ObjectValue.prototype.binop$4 = ObjectValue.prototype.binop;
 // ********** Code for GlobalValue **************
 $inherits(GlobalValue, Value);
-function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, span, _dependencies) {
+function GlobalValue(type, code, isConst, field, name, exp, span, _dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
-  this.canonicalCode = canonicalCode;
   this.dependencies = [];
   // Initializers done
   Value.call(this, type, code, span, !isConst);
   for (var $$i = 0;$$i < _dependencies.get$length(); $$i++) {
     var dep = _dependencies.$index($$i);
-    this.dependencies.add(dep);
-    this.dependencies.addAll(dep.get$dependencies());
+    if ((dep instanceof GlobalValue)) {
+      this.dependencies.add(dep);
+      this.dependencies.addAll(dep.get$dependencies());
+    }
   }
 }
-GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
-  var code = (exp.get$isConst() ? exp.get$canonicalCode() : exp.code);
-  var codeWithComment = ("" + code + "/*" + field.get$declaringType().get$name() + "." + field.get$name() + "*/");
-  return new GlobalValue(exp.get$type(), codeWithComment, field.get$isFinal(), field, null, exp, code, exp.span, dependencies.filter$1((function (d) {
-    return (d instanceof GlobalValue);
-  })
-  ));
-}
-GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
-  var name = ("const$" + uniqueId);
-  var codeWithComment = ("" + name + "/*" + _escapeForComment(exp.span.get$text()) + "*/");
-  return new GlobalValue(exp.get$type(), codeWithComment, true, null, name, exp, name, exp.span, dependencies.filter$1((function (d) {
-    return (d instanceof GlobalValue);
-  })
-  ));
-}
 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$canonicalCode = function() { return this.canonicalCode; };
-GlobalValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 GlobalValue.prototype.get$isConst = function() {
   return this.exp.get$isConst() && (this.field == null || this.field.isFinal);
 }
 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;
+    return (0);
   }
-  else if (this.dependencies.indexOf(other) >= 0) {
-    return 1;
+  else if (this.dependencies.indexOf(other) >= (0)) {
+    return (1);
   }
-  else if (other.dependencies.indexOf(this) >= 0) {
-    return -1;
+  else if (other.dependencies.indexOf(this) >= (0)) {
+    return (-1);
   }
   else if (this.dependencies.get$length() > other.dependencies.get$length()) {
-    return 1;
+    return (1);
   }
   else if (this.dependencies.get$length() < other.dependencies.get$length()) {
-    return -1;
+    return (-1);
   }
   else if (this.name == null && other.name != null) {
-    return 1;
+    return (1);
   }
   else if (this.name != null && other.name == null) {
-    return -1;
+    return (-1);
   }
   else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 GlobalValue.prototype.compareTo$1 = GlobalValue.prototype.compareTo;
 // ********** Code for BareValue **************
@@ skipping 42 matching lines @@
   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.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.reader = new LibraryReader();
   // Initializers done
 }
 World.prototype.get$functionType = function() { return this.functionType; };
@@ skipping 40 matching lines @@
   }
 }
 World.prototype._addTopName = function(named) {
   if ((named instanceof Type) && named.get$isNative()) {
     this._addJavascriptTopName(named, named.get$nativeName());
   }
   this._addJavascriptTopName(named, named.get$jsname());
 }
 World.prototype._addJavascriptTopName = function(named, name) {
   var existing = this._topNames.$index(name);
-  if (existing === named) {
+  if (existing == named) {
     if (named.get$avoidNativeName()) {
       this._renameJavascriptTopName(named);
     }
   }
   else if (existing != null) {
     this.info(("mangling matching top level name \"" + named.get$jsname() + "\" in ") + ("both \"" + named.get$library().get$jsname() + "\" and \"" + existing.get$library().get$jsname() + "\""));
     var existingPri = existing.get$jsnamePriority();
     var namedPri = named.get$jsnamePriority();
-    if (existingPri > namedPri || namedPri == 0) {
+    if (existingPri > namedPri || namedPri == (0)) {
       this._renameJavascriptTopName(named);
     }
     else if (namedPri > existingPri) {
       this._renameJavascriptTopName(existing);
     }
     else {
       var msg = ("conflicting JS name \"" + name + "\" of same ") + ("priority " + existingPri + ": (already defined in) ") + ("" + existing.get$span().get$locationText() + " with priority " + namedPri + ")");
       if (named.get$isNative()) {
         $globals.world.info(msg, named.get$span(), existing.get$span());
       }
@@ skipping 127 matching lines @@
     }
     this.libraries.$setindex(filename, library);
     this._todo.add(library);
     if (filename == "dart:dom") {
       this.dom = library;
     }
   }
   return library;
 }
 World.prototype.process = function() {
-  while (this._todo.get$length() > 0) {
+  while (this._todo.get$length() > (0)) {
     var todo = this._todo;
     this._todo = [];
     for (var $$i = 0;$$i < todo.get$length(); $$i++) {
       var lib = todo.$index($$i);
       lib.visitSources$0();
     }
   }
 }
 World.prototype.processDartScript = function(script) {
   if (script == null) script = $globals.options.dartScript;
   var library = this.getOrAddLibrary(script);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
   var $$list = this.libraries.getValues();
   for (var $$i = this.libraries.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var lib = $$i.next$0();
     lib.resolve$0();
   }
 }
 World.prototype.get$resolveAll = function() {
   return this.resolveAll.bind(this);
 }
 World.prototype.findMainMethod = function(lib) {
   var mainMembers = lib.topType.resolveMember("main");
   var main = null;
-  if (mainMembers == null || $eq(mainMembers.get$members().get$length(), 0)) {
+  if (mainMembers == null || $eq(mainMembers.get$members().get$length(), (0))) {
     this.fatal("no main method specified");
   }
-  else if (mainMembers.get$members().get$length() > 1) {
+  else if (mainMembers.get$members().get$length() > (1)) {
     var $$list = mainMembers.get$members();
     for (var $$i = mainMembers.get$members().iterator$0(); $$i.hasNext$0(); ) {
       var m = $$i.next$0();
       main = m;
       this.error("more than one main member (using last?)", main.get$span());
     }
   }
   else {
-    main = mainMembers.get$members().$index(0);
+    main = mainMembers.get$members().$index((0));
   }
   return main;
 }
 World.prototype.generateCode = function(lib) {
   var codeWriter = new CodeWriter();
   this.gen = new WorldGenerator(this.findMainMethod(lib), codeWriter);
   this.gen.run();
   this.jsBytesWritten = codeWriter.get$text().get$length();
 }
 World.prototype._message = function(color, prefix, message, span, span1, span2, throwing) {
@@ skipping 54 matching lines @@
 World.prototype.withoutForceDynamic = function(fn) {
   var oldForceDynamic = $globals.options.forceDynamic;
   $globals.options.forceDynamic = false;
   try {
     return fn();
   } finally {
     $globals.options.forceDynamic = oldForceDynamic;
   }
 }
 World.prototype.get$hasErrors = function() {
-  return this.errors > 0;
+  return this.errors > (0);
 }
 World.prototype.printStatus = function() {
   this.info(("compiled " + this.dartBytesRead + " bytes Dart -> " + this.jsBytesWritten + " bytes JS"));
   if (this.get$hasErrors()) {
     print(("compilation failed with " + this.errors + " errors"));
   }
   else {
-    if (this.warnings > 0) {
+    if (this.warnings > (0)) {
       this.info(("compilation completed successfully with " + this.warnings + " warnings"));
     }
     else {
       this.info("compilation completed sucessfully");
     }
   }
 }
 World.prototype.withTiming = function(name, f) {
   var sw = new StopwatchImplementation();
   sw.start();
@@ skipping 23 matching lines @@
   this.useColors = true
   // Initializers done
   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"));
+    $throw("Invalid configuration");
   }
   var ignoreUnrecognizedFlags = false;
   var passedLibDir = false;
   this.childArgs = [];
   loop:
-  for (var i = 2;
+  for (var i = (2);
    i < args.get$length(); i++) {
     var arg = args.$index(i);
     switch (arg) {
       case "--enable_leg":
 
         this.enableLeg = true;
         break;
 
       case "--leg_only":
 
@@ skipping 69 matching lines @@
 
       case "--no_colors":
 
         this.useColors = false;
         break;
 
       default:
 
         if (arg.endsWith$1(".dart")) {
           this.dartScript = arg;
-          this.childArgs = args.getRange(i + 1, args.get$length() - i - 1);
+          this.childArgs = args.getRange(i + (1), args.get$length() - i - (1));
           break loop;
         }
         else if (arg.startsWith$1("--out=")) {
           this.outfile = arg.substring$1("--out=".length);
         }
         else if (arg.startsWith$1("--libdir=")) {
           this.libDir = arg.substring$1("--libdir=".length);
           passedLibDir = true;
         }
         else {
@@ skipping 46 matching lines @@
   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.code + "." + this.name + "(" + args.getCode() + ")"), node.span, true);
+  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();
@@ skipping 75 matching lines @@
     code.exitBlock("};");
   }
 }
 VarMethodStub.prototype._needsExactTypeCheck = function() {
   var $this = this; // closure support
   if (this.member == null || this.member.declaringType.get$isObject()) return false;
   var members = this.member.declaringType.resolveMember(this.member.name).members;
   return members.filter$1((function (m) {
     return $ne(m, $this.member) && m.get$declaringType().get$isHiddenNativeType();
   })
-  ).get$length() >= 1;
+  ).get$length() >= (1);
 }
 VarMethodStub.prototype._useDirectCall = function(args) {
   if ((this.member instanceof MethodMember) && !this.member.declaringType.get$hasNativeSubtypes()) {
     var method = this.member;
     if (method.needsArgumentConversion(args)) {
       return false;
     }
     for (var i = args.get$length();
      i < method.parameters.get$length(); i++) {
       if ($ne(method.parameters.$index(i).get$value().get$code(), "null")) {
@@ skipping 52 matching lines @@
 VarMethodSet.prototype.invoke$4 = VarMethodSet.prototype.invoke;
 // ********** Code for top level **************
 function _otherOperator(jsname, op) {
   return ("function " + jsname + "(x, y) {\n  return (typeof(x) == 'number' && typeof(y) == 'number')\n    ? x " + op + " y : x." + jsname + "(y);\n}");
 }
 function map(source, mapper) {
   var result = new Array();
   if (!!(source && source.is$List())) {
     var list = source;
     result.set$length(list.get$length());
-    for (var i = 0;
+    for (var i = (0);
      i < list.get$length(); i++) {
       result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
     for (var $$i = source.iterator(); $$i.hasNext$0(); ) {
       var item = $$i.next$0();
       result.add(mapper(item));
     }
   }
@@ skipping 16 matching lines @@
     return x.compareTo$1(y);
   })
   );
   var values = [];
   for (var $$i = 0;$$i < keys.get$length(); $$i++) {
     var k = keys.$index($$i);
     values.add(map.$index(k));
   }
   return values;
 }
-function _escapeForComment(text) {
-  return text.replaceAll("/*", "/ *").replaceAll("*/", "* /");
-}
 var world;
 var experimentalAwaitPhase;
 var legCompile;
 function initializeWorld(files) {
   $globals.world = new World(files);
   $globals.world.init();
 }
 function compile(homedir, args, files) {
   parseOptions(homedir, args, files);
   initializeWorld(files);
@@ skipping 12 matching lines @@
     if (name0.contains$1("$")) {
       nameBuilder.add(("" + name0.get$length()));
     }
     nameBuilder.add(name0);
   }
   return nameBuilder.toString();
 }
 //  ********** Library minfrog **************
 // ********** Code for top level **************
 function main() {
-  var homedir = path.dirname(fs.realpathSync(get$process().get$argv().$index(1)));
+  var homedir = path.dirname(fs.realpathSync(get$process().get$argv().$index((1))));
   var argv = [];
-  for (var i = 0;
+  for (var i = (0);
    i < get$process().get$argv().get$length(); i++) {
     argv.add$1(get$process().get$argv().$index(i));
-    if (i == 1) {
+    if (i == (1)) {
       var terminal = get$process().get$env().$index("TERM");
       if (terminal == null || !terminal.startsWith$1("xterm")) {
         argv.add$1("--no_colors");
       }
     }
   }
   if (compile(homedir, argv, new NodeFileSystem())) {
     var code = $globals.world.getGeneratedCode();
     if ($globals.options.compileOnly) {
       if ($globals.options.outfile != null) {
         print(("Compilation succeded. Code generated in: " + $globals.options.outfile));
       }
       else {
         print("Compilation succeded.");
       }
     }
     else {
-      get$process().set$argv([argv.$index(0), argv.$index(1)]);
+      get$process().set$argv([argv.$index((0)), argv.$index((1))]);
       get$process().get$argv().addAll($globals.options.childArgs);
       vm.runInNewContext(code, createSandbox());
     }
   }
   else {
-    get$process().exit(1);
+    get$process().exit((1));
   }
 }
 // ********** Generic Type Inheritance **************
 /** Implements extends for generic types. */
 function $inheritsMembers(child, parent) {
   child = child.prototype;
   parent = parent.prototype;
   Object.getOwnPropertyNames(parent).forEach(function(name) {
     if (typeof(child[name]) == 'undefined') child[name] = parent[name];
   });
@@ skipping 11 matching lines @@
   $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 $globals = {};
 $static_init();
 main();