Throw FallThroughError when we fall through a case in a switch statement. Fixes

frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 284 matching lines @@
 function AssertError() {}
 AssertError.prototype.toString = function() {
   return ("Failed assertion: '" + this.failedAssertion + "' is not true ") + ("in " + this.url + " at line " + this.line + ", column " + this.column + ".");
 }
 // ********** Code for TypeError **************
 function TypeError() {}
 $inherits(TypeError, AssertError);
 TypeError.prototype.toString = function() {
   return ("Failed type check: type " + this.srcType + " is not assignable to type ") + ("" + this.dstType + " of " + this.dstName + " in " + this.url + " at line ") + ("" + this.line + ", column " + this.column + ".");
 }
+// ********** Code for FallThroughError **************
+function FallThroughError() {}
+FallThroughError.prototype.toString = function() {
+  return ("Switch case fall-through in " + this.url + " at line " + this.line + ".");
+}
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
 $defineMethod(Object, "forEach$1", function($0) {
   return this.noSuchMethod("forEach$1", [$0]);
 }
@@ skipping 159 matching lines @@
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for JSSyntaxRegExp **************
 function JSSyntaxRegExp() {}
 JSSyntaxRegExp._create$ctor = function(pattern, flags) {
   this.re = new RegExp(pattern, flags);
       this.pattern = pattern;
       this.multiLine = this.re.multiline;
       this.ignoreCase = this.re.ignoreCase;
@@ skipping 16 matching lines @@
 }
 // ********** Code for _AllMatchesIterator **************
 function _AllMatchesIterator(re, _str) {
   this._str = _str;
   this._done = false;
   this._re = new JSSyntaxRegExp._create$ctor(re.pattern, 'g' + (re.multiLine ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
   // Initializers done
 }
 _AllMatchesIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   var next = this._next;
   this._next = null;
   return next;
 }
 _AllMatchesIterator.prototype.hasNext = function() {
   if (this._done) {
     return false;
   }
   else if (this._next) {
@@ skipping 31 matching lines @@
 
     if (truncated == -0.0) return 0;
     return truncated;
 }
 NumImplementation.prototype.toDouble = function() {
   return this + 0;
 }
 NumImplementation.prototype.compareTo = function(other) {
   var thisValue = this.toDouble();
   if (thisValue < other) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (thisValue > other) {
     return 1;
   }
   else if (thisValue == other) {
     if (thisValue == 0) {
       var thisIsNegative = this.isNegative();
       var otherIsNegative = other.isNegative();
       if ($eq(thisIsNegative, otherIsNegative)) return 0;
-      if (thisIsNegative) return -1;
+      if (thisIsNegative) return -1.000000/*-1*/;
       return 1;
     }
     return 0;
   }
   else if (this.isNaN()) {
     if (other.isNaN()) {
       return 0;
     }
     return 1;
   }
   else {
-    return -1;
+    return -1.000000/*-1*/;
   }
 }
 // ********** Code for DurationImplementation **************
 function DurationImplementation(days, hours, minutes, seconds, milliseconds) {
-  this._durationInMilliseconds = days * 86400000/*Duration.MILLISECONDS_PER_DAY*/ + hours * 3600000/*Duration.MILLISECONDS_PER_HOUR*/ + minutes * 60000/*Duration.MILLISECONDS_PER_MINUTE*/ + seconds * 1000/*Duration.MILLISECONDS_PER_SECOND*/ + milliseconds;
+  this._durationInMilliseconds = days * 86400000.000000/*Duration.MILLISECONDS_PER_DAY*/ + hours * 3600000.000000/*Duration.MILLISECONDS_PER_HOUR*/ + minutes * 60000.000000/*Duration.MILLISECONDS_PER_MINUTE*/ + seconds * 1000/*Duration.MILLISECONDS_PER_SECOND*/ + milliseconds;
   // Initializers done
 }
 DurationImplementation.prototype.get$inHours = function() {
-  return $truncdiv(this._durationInMilliseconds, 3600000/*Duration.MILLISECONDS_PER_HOUR*/);
+  return $truncdiv(this._durationInMilliseconds, 3600000.000000/*Duration.MILLISECONDS_PER_HOUR*/);
 }
 DurationImplementation.prototype.get$inMinutes = function() {
-  return $truncdiv(this._durationInMilliseconds, 60000/*Duration.MILLISECONDS_PER_MINUTE*/);
+  return $truncdiv(this._durationInMilliseconds, 60000.000000/*Duration.MILLISECONDS_PER_MINUTE*/);
 }
 DurationImplementation.prototype.get$inSeconds = function() {
   return $truncdiv(this._durationInMilliseconds, 1000/*Duration.MILLISECONDS_PER_SECOND*/);
 }
 DurationImplementation.prototype.get$inMilliseconds = function() {
   return this._durationInMilliseconds;
 }
 DurationImplementation.prototype.$eq = function(other) {
   if (!((other instanceof DurationImplementation))) return false;
   return this._durationInMilliseconds == other.get$inMilliseconds();
@@ skipping 54 matching lines @@
 HashMapImplementation._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = -1.000000/*-1*/;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return -1.000000/*-1*/;
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
@@ skipping 83 matching lines @@
 HashMapImplementation.prototype.getValues = function() {
   var list = new ListFactory$V(this.get$length());
   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.000000/*-1*/);
 }
 $defineMethod(HashMapImplementation, "forEach$1", HashMapImplementation.prototype.forEach);
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$E(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$E$E, HashMapImplementation);
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  var insertionIndex = -1;
+  var insertionIndex = -1.000000/*-1*/;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
     else if ($eq(existingKey, key)) {
       return hash;
     }
     else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   while (true) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
+    if (existingKey == null) return -1.000000/*-1*/;
     if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
   if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
@@ skipping 63 matching lines @@
 HashMapImplementation$E$E.prototype.getKeys = function() {
   var list = new ListFactory$E(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation$E$E.prototype.containsKey = function(key) {
-  return (this._probeForLookup(key) != -1);
+  return (this._probeForLookup(key) != -1.000000/*-1*/);
 }
 // ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
 function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
@@ skipping 99 matching lines @@
 }
 $defineMethod(HashSetImplementation, "forEach$1", HashSetImplementation.prototype.forEach);
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
-  this._nextValidIndex = -1;
+  this._nextValidIndex = -1.000000/*-1*/;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   if (this._nextValidIndex >= this._entries.length) return false;
   if (this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
     if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for HashSetIterator$E **************
 function HashSetIterator$E(set_) {
-  this._nextValidIndex = -1;
+  this._nextValidIndex = -1.000000/*-1*/;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 $inherits(HashSetIterator$E, HashSetIterator);
 HashSetIterator$E.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
@@ skipping 182 matching lines @@
 function DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {}
 $inherits(DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, DoubleLinkedQueueEntry);
 // ********** Code for _DoubleLinkedQueueEntrySentinel **************
 function _DoubleLinkedQueueEntrySentinel() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel, DoubleLinkedQueueEntry$E);
 _DoubleLinkedQueueEntrySentinel.prototype.remove = function() {
-  $throw(const$10/*const EmptyQueueException()*/);
+  $throw(const$122/*const EmptyQueueException()*/);
 }
 _DoubleLinkedQueueEntrySentinel.prototype._asNonSentinelEntry = function() {
   return null;
 }
 _DoubleLinkedQueueEntrySentinel.prototype.get$element = function() {
-  $throw(const$10/*const EmptyQueueException()*/);
+  $throw(const$122/*const EmptyQueueException()*/);
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel$E **************
 function _DoubleLinkedQueueEntrySentinel$E() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$E, _DoubleLinkedQueueEntrySentinel);
 _DoubleLinkedQueueEntrySentinel$E.prototype._link = function(p, n) {
   this._next = n;
@@ skipping 161 matching lines @@
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if (!this.hasNext()) {
-    $throw(const$9/*const NoMoreElementsException()*/);
+    $throw(const$121/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 // ********** Code for _DoubleLinkedQueueIterator$E **************
 function _DoubleLinkedQueueIterator$E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
@@ skipping 413 matching lines @@
       if (pieces.length > 0 && $eq(pieces.last(), '.')) {
         pieces.removeLast();
       }
       pieces.add(piece);
     }
   }
   return Strings.join(pieces, '/');
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == -1.000000/*-1*/) {
     return '.';
   }
   else {
     return path.substring(0, lastSlash);
   }
 }
 function basename(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if (lastSlash == -1.000000/*-1*/) {
     return path;
   }
   else {
     return path.substring(lastSlash + 1);
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
   // Initializers done
@@ skipping 17 matching lines @@
 }
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
   if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
   var result = new LinkedHashMapImplementation$String$Keyword();
-  for (var $i = 0;$i < const$326/*Keyword.values*/.length; $i++) {
-    var keyword = const$326/*Keyword.values*/.$index($i);
+  for (var $i = 0;$i < const$316/*Keyword.values*/.length; $i++) {
+    var keyword = const$316/*Keyword.values*/.$index($i);
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
   return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 Keyword.prototype.toString = function() {
   return this.syntax;
 }
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
-    var strings = new ListFactory$String(const$326/*Keyword.values*/.length);
+    var strings = new ListFactory$String(const$316/*Keyword.values*/.length);
     for (var i = 0;
-     i < const$326/*Keyword.values*/.length; i++) {
-      strings.$setindex(i, const$326/*Keyword.values*/.$index(i).syntax);
+     i < const$316/*Keyword.values*/.length; i++) {
+      strings.$setindex(i, const$316/*Keyword.values*/.$index(i).syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo(b);
     })
     );
     KeywordState._KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
   }
   return KeywordState._KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
   var result = new ListFactory$KeywordState(26);
   var chunk = 0;
-  var chunkStart = -1;
+  var chunkStart = -1.000000/*-1*/;
   for (var i = offset;
    i < offset + length; i++) {
     if (strings.$index(i).length > start) {
       var c = strings.$index(i).charCodeAt(start);
       if (chunk != c) {
-        if (chunkStart != -1) {
+        if (chunkStart != -1.000000/*-1*/) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
-  if (chunkStart != -1) {
+  if (chunkStart != -1.000000/*-1*/) {
     result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart));
   }
   else {
     return new LeafKeywordState(strings.$index(offset));
   }
   return new ArrayKeywordState(result);
 }
 // ********** Code for ArrayKeywordState **************
 function ArrayKeywordState(table) {
   this.table = table;
@@ skipping 34 matching lines @@
   return true;
 }
 LeafKeywordState.prototype.next = function(c) {
   return null;
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
 // ********** Code for ArrayBasedScanner **************
 function ArrayBasedScanner() {
-  this.charOffset = -1;
-  this.tokenStart = -1;
-  this.byteOffset = -1;
-  this.tokens = new Token(0, -1);
+  this.charOffset = -1.000000/*-1*/;
+  this.tokenStart = -1.000000/*-1*/;
+  this.byteOffset = -1.000000/*-1*/;
+  this.tokens = new scanner_Token(0, -1.000000/*-1*/);
   // Initializers done
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner, AbstractScanner$S);
 ArrayBasedScanner.prototype.get$charOffset = function() { return this.charOffset; };
 ArrayBasedScanner.prototype.set$charOffset = function(value) { return this.charOffset = value; };
 ArrayBasedScanner.prototype.get$byteOffset = function() { return this.byteOffset; };
 ArrayBasedScanner.prototype.set$byteOffset = function(value) { return this.byteOffset = value; };
 ArrayBasedScanner.prototype.advance = function() {
   var next = this.nextByte();
@@ skipping 26 matching lines @@
   return this.tokens.next;
 }
 ArrayBasedScanner.prototype.addToCharOffset = function(offset) {
   this.charOffset += offset;
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 // ********** Code for ArrayBasedScanner$String **************
 function ArrayBasedScanner$String() {
-  this.charOffset = -1;
-  this.tokenStart = -1;
-  this.byteOffset = -1;
-  this.tokens = new Token(0, -1);
+  this.charOffset = -1.000000/*-1*/;
+  this.tokenStart = -1.000000/*-1*/;
+  this.byteOffset = -1.000000/*-1*/;
+  this.tokens = new scanner_Token(0, -1.000000/*-1*/);
   // Initializers done
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$String, ArrayBasedScanner);
 ArrayBasedScanner$String.prototype.advance = function() {
   var next = this.nextByte();
   this.charOffset++;
   return next;
 }
 ArrayBasedScanner$String.prototype.select = function(choice, yes, no) {
@@ skipping 22 matching lines @@
   return this.tokens.next;
 }
 ArrayBasedScanner$String.prototype.addToCharOffset = function(offset) {
   this.charOffset += offset;
 }
 ArrayBasedScanner$String.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner$String.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 ArrayBasedScanner$String.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
@@ skipping 198 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.charOffset);
         $throw(new MalformedInputException(this.charOffset));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeTag = function(next) {
@@ skipping 154 matching lines @@
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
@@ skipping 223 matching lines @@
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
@@ skipping 17 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.byteOffset;
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeRawString = function(next) {
   var start = this.byteOffset;
   next = this.advance();
   if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.charOffset));
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
   if (q == next) {
     next = this.advance();
     if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
-      this.appendByteStringToken(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-1*/) {
         $throw(new MalformedInputException(this.charOffset));
       }
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for top level **************
 //  ********** Library util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
 LinkFactory.Link$factory = function(head, tail) {
-  return new LinkEntry(head, (tail == null) ? const$328/*const LinkTail()*/ : tail);
+  return new LinkEntry(head, (tail == null) ? const$318/*const LinkTail()*/ : tail);
 }
 LinkFactory.Link$fromList$factory = function(list) {
   switch (list.length) {
     case 0:
 
-      return const$328/*const LinkTail()*/;
+      return const$318/*const LinkTail()*/;
 
     case 1:
 
       return LinkFactory.Link$factory(list.$index(0));
 
     case 2:
 
       return LinkFactory.Link$factory(list.$index(0), LinkFactory.Link$factory(list.$index(1)));
 
     case 3:
@@ skipping 30 matching lines @@
   // Initializers done
 }
 $inherits(LinkTail, AbstractLink$T);
 LinkTail.prototype.get$head = function() {
   return null;
 }
 LinkTail.prototype.get$tail = function() {
   return null;
 }
 LinkTail.prototype.toList = function() {
-  return const$8/*const <HInstruction>[]*/;
+  return const$120/*const <HInstruction>[]*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
@@ skipping 27 matching lines @@
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {}
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 AbstractScanner.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
@@ skipping 198 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.get$charOffset());
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner.prototype.tokenizeTag = function(next) {
@@ skipping 154 matching lines @@
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
@@ skipping 223 matching lines @@
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
@@ skipping 17 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
 AbstractScanner.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
   if (q == next) {
     next = this.advance();
     if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
-      this.appendByteStringToken(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-1*/) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for AbstractScanner$S **************
 function AbstractScanner$S() {}
 $inherits(AbstractScanner$S, AbstractScanner);
 AbstractScanner$S.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     next = this.bigSwitch(next);
   }
   return this.firstToken();
 }
 AbstractScanner$S.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
     case 13/*null.$CR*/:
@@ skipping 198 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if (next == -1) {
-        return -1;
+      if (next == -1.000000/*-1*/) {
+        return -1.000000/*-1*/;
       }
       if (next < 0x1f) {
         $throw(this.get$charOffset());
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner$S.prototype.tokenizeTag = function(next) {
@@ skipping 154 matching lines @@
         case 62/*null.$GT*/:
 
           return this.select(61/*null.$EQ*/, ">>>=", ">>>");
 
         default:
 
           this.appendStringToken(62/*null.$GT*/, ">>");
           return next;
 
       }
+      $throw(new FallThroughError("leg/scanner/scanner.dart", 389))
 
     default:
 
       this.appendStringToken(62/*null.$GT*/, ">");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeLessThan = function(next) {
   next = this.advance();
@@ skipping 223 matching lines @@
 
       this.appendStringToken(47/*null.$SLASH*/, "/");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineComment = function(next) {
   while (true) {
     next = this.advance();
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
   while (true) {
     switch (next) {
-      case -1:
+      case -1.000000/*-1*/:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
         if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if (next == -1.000000/*-1*/) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
@@ skipping 17 matching lines @@
       state = null;
     }
     else if (next < 128) {
       if (state != null && state.isLeaf()) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if (isAscii) {
         this.appendByteStringToken(97/*null.$a*/, this.asciiString(start));
       }
       else {
-        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1));
+        this.appendByteStringToken(97/*null.$a*/, this.utf8String(start, -1.000000/*-1*/));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
       while (next > 127)
-      var string = this.utf8String(nonAsciiStart, -1).toString();
+      var string = this.utf8String(nonAsciiStart, -1.000000/*-1*/).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
   if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
 AbstractScanner$S.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
   if (q == next) {
     next = this.advance();
     if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
-      this.appendByteStringToken(q, this.utf8String(start, -1));
+      this.appendByteStringToken(q, this.utf8String(start, -1.000000/*-1*/));
       return next;
     }
   }
   if (raw) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if (next == -1) {
+      if (next == -1.000000/*-1*/) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner$S.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q1) {
       this.appendByteStringToken(q1, this.utf8String(start, 0));
       return this.advance();
     }
     else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner$S.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
+  while (next != -1.000000/*-1*/) {
     if (next == q) {
       next = this.advance();
       if (next == q) {
         next = this.advance();
         if (next == q) {
           this.appendByteStringToken(q, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for MalformedInputException **************
 function MalformedInputException(ignored) {
   // Initializers done
 }
-// ********** Code for Parser **************
-function Parser(listener) {
+// ********** Code for scanner_Parser **************
+function scanner_Parser(listener) {
   this.listener = listener;
   // Initializers done
 }
-Parser.prototype.next = function(token) {
+scanner_Parser.prototype.next = function(token) {
   return this.checkEof(token.next);
 }
-Parser.prototype.checkEof = function(token) {
+scanner_Parser.prototype.checkEof = function(token) {
   if (token == null) {
     this.listener.unexpectedEof();
     $throw("Unexpected EOF");
   }
   return token;
 }
-Parser.prototype.parseUnit = function(token) {
+scanner_Parser.prototype.parseUnit = function(token) {
   while (token != null) {
     switch (token.get$value()) {
-      case const$308/*Keyword.INTERFACE*/:
+      case const$298/*Keyword.INTERFACE*/:
 
         token = this.parseInterface(token);
         break;
 
-      case const$296/*Keyword.CLASS*/:
+      case const$286/*Keyword.CLASS*/:
 
         token = this.parseClass(token);
         break;
 
-      case const$324/*Keyword.TYPEDEF*/:
+      case const$314/*Keyword.TYPEDEF*/:
 
         token = this.parseNamedFunctionAlias(token);
         break;
 
-      case const$338/*const SourceString("#")*/:
+      case const$328/*const SourceString("#")*/:
 
         token = this.parseLibraryTags(token);
         break;
 
       default:
 
         token = this.parseTopLevelMember(token);
         break;
 
     }
   }
 }
-Parser.prototype.parseInterface = function(token) {
+scanner_Parser.prototype.parseInterface = function(token) {
   this.listener.beginInterface(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSupertypesClauseOpt(token);
   token = this.parseFactoryClauseOpt(token);
   return this.parseInterfaceBody(token);
 }
-Parser.prototype.parseInterfaceBody = function(token) {
+scanner_Parser.prototype.parseInterfaceBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endInterface(token);
   return token.next;
 }
-Parser.prototype.parseNamedFunctionAlias = function(token) {
+scanner_Parser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
   token = this.parseParameters(token);
   this.listener.endFunctionTypeAlias(token);
-  return this.expect(const$337/*const SourceString(";")*/, token);
+  return this.expect(const$327/*const SourceString(";")*/, token);
 }
-Parser.prototype.parseReturnTypeOpt = function(token) {
-  if ($eq(token.get$value(), const$288/*Keyword.VOID*/)) {
+scanner_Parser.prototype.parseReturnTypeOpt = function(token) {
+  if ($eq(token.get$value(), const$278/*Keyword.VOID*/)) {
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
-Parser.prototype.parseParameters = function(token) {
-  this.expect(const$335/*const SourceString("(")*/, token);
-  if (this.optional(const$336/*const SourceString(")")*/, this.next(token))) {
+scanner_Parser.prototype.parseParameters = function(token) {
+  this.expect(const$325/*const SourceString("(")*/, token);
+  if (this.optional(const$326/*const SourceString(")")*/, this.next(token))) {
     return this.next(this.next(token));
   }
   do {
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
   }
-  while (this.optional(const$331/*const SourceString(",")*/, token))
-  return this.expect(const$336/*const SourceString(")")*/, token);
+  while (this.optional(const$321/*const SourceString(",")*/, token))
+  return this.expect(const$326/*const SourceString(")")*/, token);
 }
-Parser.prototype.parseTypeOpt = function(token) {
+scanner_Parser.prototype.parseTypeOpt = function(token) {
   switch (true) {
-    case this.optional(const$329/*const SourceString("<")*/, this.next(token)):
-    case this.optional(const$330/*const SourceString(".")*/, this.next(token)):
+    case this.optional(const$319/*const SourceString("<")*/, this.next(token)):
+    case this.optional(const$320/*const SourceString(".")*/, this.next(token)):
     case this.isIdentifier(this.next(token)):
 
       return this.parseType(token);
 
     default:
 
       return token;
 
   }
 }
-Parser.prototype.isIdentifier = function(token) {
+scanner_Parser.prototype.isIdentifier = function(token) {
   switch (token.kind) {
     case 97/*null.$a*/:
 
       return true;
 
     case 107/*null.$k*/:
 
       return token.get$value().isPseudo;
 
     default:
 
       return false;
 
   }
 }
-Parser.prototype.parseSupertypesClauseOpt = function(token) {
-  if (this.optional(const$298/*Keyword.EXTENDS*/, token)) {
+scanner_Parser.prototype.parseSupertypesClauseOpt = function(token) {
+  if (this.optional(const$288/*Keyword.EXTENDS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$331/*const SourceString(",")*/, token))
+    while (this.optional(const$321/*const SourceString(",")*/, token))
   }
   return token;
 }
-Parser.prototype.parseFactoryClauseOpt = function(token) {
-  if (this.optional(const$300/*Keyword.FACTORY*/, token)) {
+scanner_Parser.prototype.parseFactoryClauseOpt = function(token) {
+  if (this.optional(const$290/*Keyword.FACTORY*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
-Parser.prototype.skipBlock = function(token) {
-  if (!this.optional(const$333/*const SourceString("{")*/, token)) return this.listener.expectedBlock(token);
+scanner_Parser.prototype.skipBlock = function(token) {
+  if (!this.optional(const$323/*const SourceString("{")*/, token)) return this.listener.expectedBlock(token);
   token = this.next(token);
   var nesting = 1;
   do {
     switch (token.kind) {
       case 123/*null.$LBRACE*/:
 
         nesting++;
         break;
 
       case 125/*null.$RBRACE*/:
 
         nesting--;
         if (nesting == 0) {
           return token;
         }
         break;
 
     }
     token = this.next(token);
   }
   while (token != null)
   $throw("Internal error: unreachable code");
 }
-Parser.prototype.parseClass = function(token) {
+scanner_Parser.prototype.parseClass = function(token) {
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSuperclassClauseOpt(token);
   token = this.parseImplementsOpt(token);
   token = this.parseNativeClassClauseOpt(token);
   return this.parseClassBody(token);
 }
-Parser.prototype.parseNativeClassClauseOpt = function(token) {
-  if (this.optional(const$312/*Keyword.NATIVE*/, token)) {
+scanner_Parser.prototype.parseNativeClassClauseOpt = function(token) {
+  if (this.optional(const$302/*Keyword.NATIVE*/, token)) {
     return this.parseString(this.next(token));
   }
   return token;
 }
-Parser.prototype.parseString = function(token) {
+scanner_Parser.prototype.parseString = function(token) {
   switch (token.kind) {
     case 39/*null.$SQ*/:
     case 34/*null.$DQ*/:
 
       return this.next(token);
 
     default:
 
-      return this.listener.expected(const$334/*const SourceString("string")*/, token);
+      return this.listener.expected(const$324/*const SourceString("string")*/, token);
 
   }
 }
-Parser.prototype.parseIdentifier = function(token) {
+scanner_Parser.prototype.parseIdentifier = function(token) {
   if (this.isIdentifier(token)) {
     this.listener.identifier(token);
   }
   else {
     this.listener.notIdentifier(token);
   }
   return this.next(token);
 }
-Parser.prototype.parseTypeVariablesOpt = function(token) {
-  if (!this.optional(const$329/*const SourceString("<")*/, token)) {
+scanner_Parser.prototype.parseTypeVariablesOpt = function(token) {
+  if (!this.optional(const$319/*const SourceString("<")*/, token)) {
     return token;
   }
   this.listener.beginTypeVariables(token);
   do {
     token = this.parseTypeVariable(this.next(token));
   }
-  while (this.optional(const$331/*const SourceString(",")*/, token))
-  return this.expect(const$332/*const SourceString(">")*/, token);
+  while (this.optional(const$321/*const SourceString(",")*/, token))
+  return this.expect(const$322/*const SourceString(">")*/, token);
 }
-Parser.prototype.expect = function(string, token) {
+scanner_Parser.prototype.expect = function(string, token) {
   if ($ne(string, token.get$value())) {
     return this.listener.expected(string, token);
   }
   return token.next;
 }
-Parser.prototype.parseTypeVariable = function(token) {
+scanner_Parser.prototype.parseTypeVariable = function(token) {
   this.listener.beginTypeVariable(token);
   token = this.parseIdentifier(token);
   token = this.parseSuperclassClauseOpt(token);
   this.listener.endTypeVariable(token);
   return token;
 }
-Parser.prototype.optional = function(value, token) {
+scanner_Parser.prototype.optional = function(value, token) {
   return $eq(value, token.get$value());
 }
-Parser.prototype.parseSuperclassClauseOpt = function(token) {
-  if (this.optional(const$298/*Keyword.EXTENDS*/, token)) {
+scanner_Parser.prototype.parseSuperclassClauseOpt = function(token) {
+  if (this.optional(const$288/*Keyword.EXTENDS*/, token)) {
     return this.parseType(this.next(token));
   }
   return token;
 }
-Parser.prototype.parseType = function(token) {
+scanner_Parser.prototype.parseType = function(token) {
   if (this.isIdentifier(token)) {
     token = this.parseIdentifier(token);
-    while (this.optional(const$330/*const SourceString(".")*/, token)) {
+    while (this.optional(const$320/*const SourceString(".")*/, token)) {
       token = this.parseIdentifier(this.next(token));
     }
   }
   else {
     token = this.listener.expectedType(token);
   }
   return this.parseTypeArgumentsOpt(token);
 }
-Parser.prototype.parseTypeArgumentsOpt = function(token) {
-  if (this.optional(const$329/*const SourceString("<")*/, token)) {
+scanner_Parser.prototype.parseTypeArgumentsOpt = function(token) {
+  if (this.optional(const$319/*const SourceString("<")*/, token)) {
     this.listener.beginTypeArguments(this.next(token));
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$331/*const SourceString(",")*/, token))
-    return this.expect(const$332/*const SourceString(">")*/, token);
+    while (this.optional(const$321/*const SourceString(",")*/, token))
+    return this.expect(const$322/*const SourceString(">")*/, token);
   }
   return token;
 }
-Parser.prototype.parseImplementsOpt = function(token) {
-  if (this.optional(const$304/*Keyword.IMPLEMENTS*/, token)) {
+scanner_Parser.prototype.parseImplementsOpt = function(token) {
+  if (this.optional(const$294/*Keyword.IMPLEMENTS*/, token)) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$331/*const SourceString(",")*/, token))
+    while (this.optional(const$321/*const SourceString(",")*/, token))
   }
   return token;
 }
-Parser.prototype.parseClassBody = function(token) {
+scanner_Parser.prototype.parseClassBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endClass(token);
   return token.next;
 }
-Parser.prototype.parseTopLevelMember = function(token) {
+scanner_Parser.prototype.parseTopLevelMember = function(token) {
   var start = token;
   this.listener.beginTopLevelMember(token);
   var previous = token;
   LOOP:
   while (token != null) {
     switch (token.kind) {
       case 123/*null.$LBRACE*/:
       case 59/*null.$SEMICOLON*/:
       case 40/*null.$LPAREN*/:
       case 61/*null.$EQ*/:
 
         break LOOP;
 
       default:
 
         token = this.next(previous = token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
-  if (this.optional(const$335/*const SourceString("(")*/, token)) {
+  if (this.optional(const$325/*const SourceString("(")*/, token)) {
     this.listener.topLevelMethod(start);
   }
-  else if (this.optional(const$339/*const SourceString("=")*/, token) || this.optional(const$337/*const SourceString(";")*/, token)) {
+  else if (this.optional(const$329/*const SourceString("=")*/, token) || this.optional(const$327/*const SourceString(";")*/, token)) {
     this.listener.topLevelField(start);
   }
   else {
     token = this.listener.unexpected(token);
   }
   while (token != null && token.kind != 123/*null.$LBRACE*/ && token.kind != 59/*null.$SEMICOLON*/) {
     token = this.next(token);
   }
-  if (!this.optional(const$337/*const SourceString(";")*/, token)) {
+  if (!this.optional(const$327/*const SourceString(";")*/, token)) {
     token = this.skipBlock(token);
   }
   this.listener.endTopLevelMember(token);
   return token.next;
 }
-Parser.prototype.parseLibraryTags = function(token) {
+scanner_Parser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
-  token = this.expect(const$335/*const SourceString("(")*/, token);
+  token = this.expect(const$325/*const SourceString("(")*/, token);
   while (token != null && token.kind != 40/*null.$LPAREN*/ && token.kind != 41/*null.$RPAREN*/) {
     token = this.next(token);
   }
-  token = this.expect(const$336/*const SourceString(")")*/, token);
-  return this.expect(const$337/*const SourceString(";")*/, token);
+  token = this.expect(const$326/*const SourceString(")")*/, token);
+  return this.expect(const$327/*const SourceString(";")*/, token);
 }
 // ********** Code for BodyParser **************
 function BodyParser(listener) {
-  Parser.call(this, listener);
+  scanner_Parser.call(this, listener);
   // Initializers done
 }
-$inherits(BodyParser, Parser);
+$inherits(BodyParser, scanner_Parser);
 BodyParser.prototype.parseMethod = function(token) {
   token = this.parseReturnType(token);
   token = this.parseIdentifier(token);
   token = this.parseFormalParameters(token);
   return this.parseMethodBody(token);
 }
 BodyParser.prototype.parseReturnType = function(token) {
-  if (this.optional(const$288/*Keyword.VOID*/, token)) {
+  if (this.optional(const$278/*Keyword.VOID*/, token)) {
     return token.next;
   }
   return this.parseType(token);
 }
 BodyParser.prototype.parseFormalParameters = function(token) {
   this.listener.beginArguments(token);
-  this.expect(const$335/*const SourceString("(")*/, token);
-  if (this.optional(const$336/*const SourceString(")")*/, token.next)) {
+  this.expect(const$325/*const SourceString("(")*/, token);
+  if (this.optional(const$326/*const SourceString(")")*/, token.next)) {
     return token.next.next;
   }
   do {
     token = this.parseType(this.next(token));
     token = this.parseIdentifier(token);
   }
-  while (this.optional(const$331/*const SourceString(",")*/, token))
-  return this.expect(const$336/*const SourceString(")")*/, token);
+  while (this.optional(const$321/*const SourceString(",")*/, token))
+  return this.expect(const$326/*const SourceString(")")*/, token);
 }
 BodyParser.prototype.parseMethodBody = function(token) {
-  if (this.optional(const$337/*const SourceString(";")*/, token)) {
+  if (this.optional(const$327/*const SourceString(";")*/, token)) {
     return token.next;
   }
-  token = this.checkEof(this.expect(const$333/*const SourceString("{")*/, token));
-  while (!this.optional(const$340/*const SourceString("}")*/, token)) {
+  token = this.checkEof(this.expect(const$323/*const SourceString("{")*/, token));
+  while (!this.optional(const$330/*const SourceString("}")*/, token)) {
     token = this.parseStatement(token);
   }
-  return this.expect(const$340/*const SourceString("}")*/, token);
+  return this.expect(const$330/*const SourceString("}")*/, token);
 }
 BodyParser.prototype.parseStatement = function(token) {
   this.checkEof(token);
   switch (token.get$value()) {
-    case const$272/*Keyword.RETURN*/:
+    case const$262/*Keyword.RETURN*/:
 
       token = this.expectSemicolon(this.parseReturnStatement(token));
       break;
 
     default:
 
       token = this.expectSemicolon(this.parseExpression(token));
       break;
 
   }
   this.listener.endStatement(token);
   return token;
 }
 BodyParser.prototype.expectSemicolon = function(token) {
-  return this.expect(const$337/*const SourceString(";")*/, token);
+  return this.expect(const$327/*const SourceString(";")*/, token);
 }
 BodyParser.prototype.parseReturnStatement = function(token) {
   this.listener.beginReturnStatement(token);
   return this.parseExpression(this.next(token));
 }
 BodyParser.prototype.parseExpression = function(token) {
   switch (token.kind) {
     case 105/*null.$i*/:
 
       token = this.parseLiteralNumber(token);
@@ skipping 10 matching lines @@
       this.listener.unexpected(token);
       $throw("not yet implemented");
 
   }
   return token;
 }
 BodyParser.prototype.parseLiteralNumber = function(token) {
   return token.next;
 }
 BodyParser.prototype.parseArgumentsOpt = function(token) {
-  if (this.optional(const$335/*const SourceString("(")*/, token)) {
+  if (this.optional(const$325/*const SourceString("(")*/, token)) {
     this.listener.beginArguments(token);
     do {
       token = this.parseExpression(this.next(token));
     }
-    while (this.optional(const$331/*const SourceString(",")*/, token))
-    return this.expect(const$336/*const SourceString(")")*/, token);
+    while (this.optional(const$321/*const SourceString(",")*/, token))
+    return this.expect(const$326/*const SourceString(")")*/, token);
   }
   return token;
 }
 // ********** Code for Listener **************
 function Listener(canceler) {
   this.classCount = 0
   this.aliasCount = 0
   this.interfaceCount = 0
   this.libraryTagCount = 0
   this.topLevelMemberCount = 0
@@ skipping 43 matching lines @@
 Listener.prototype.beginTypeVariable = function(token) {
 
 }
 Listener.prototype.endTypeVariable = function(token) {
 
 }
 Listener.prototype.beginTypeVariables = function(token) {
 
 }
 Listener.prototype.identifier = function(token) {
-  this.previousIdentifier = new Identifier(token);
+  this.previousIdentifier = new tree_Identifier(token);
 }
 Listener.prototype.beginTypeArguments = function(token) {
 
 }
 Listener.prototype.expected = function(string, token) {
   this.canceler.cancel(("Expected '" + string + "', but got '" + token + "' ") + ("@ " + token.charOffset + ""));
 }
 Listener.prototype.unexpectedEof = function() {
   this.canceler.cancel("Unexpected end of file");
 }
@@ skipping 78 matching lines @@
   // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$String);
 StringScanner.prototype.nextByte = function() {
   return this.charAt(++this.byteOffset);
 }
 StringScanner.prototype.peek = function() {
   return this.charAt(this.byteOffset + 1);
 }
 StringScanner.prototype.charAt = function(index) {
-  return (this.string.length > index) ? this.string.charCodeAt(index) : -1;
+  return (this.string.length > index) ? this.string.charCodeAt(index) : -1.000000/*-1*/;
 }
 StringScanner.prototype.asciiString = function(start) {
   return this.string.substring(start, this.byteOffset);
 }
 StringScanner.prototype.utf8String = function(start, offset) {
   return this.string.substring(start, this.byteOffset + offset + 1);
 }
 StringScanner.prototype.appendByteStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
   this.tail = this.tail.next;
 }
-// ********** Code for Token **************
-function Token(kind, charOffset) {
+// ********** Code for scanner_Token **************
+function scanner_Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
-Token.prototype.toString = function() {
+scanner_Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
 // ********** Code for KeywordToken **************
 function KeywordToken(value, charOffset) {
   this.value = value;
-  Token.call(this, 107/*null.$k*/, charOffset);
+  scanner_Token.call(this, 107/*null.$k*/, charOffset);
   // Initializers done
 }
-$inherits(KeywordToken, Token);
+$inherits(KeywordToken, scanner_Token);
 KeywordToken.prototype.get$value = function() { return this.value; };
 KeywordToken.prototype.toString = function() {
   return this.value.syntax;
 }
 // ********** Code for StringToken **************
 function StringToken(kind, value, charOffset) {
   this.value = new StringWrapper(value);
-  Token.call(this, kind, charOffset);
+  scanner_Token.call(this, kind, charOffset);
   // Initializers done
 }
-$inherits(StringToken, Token);
+$inherits(StringToken, scanner_Token);
 StringToken.prototype.get$value = function() { return this.value; };
 StringToken.prototype.toString = function() {
   return this.value.toString();
 }
 // ********** Code for StringWrapper **************
 function StringWrapper(my_personal_string_and_you_cannot_have_it) {
   this.my_personal_string_and_you_cannot_have_it = my_personal_string_and_you_cannot_have_it;
   // Initializers done
 }
 StringWrapper.prototype.is$SourceString = function(){return this;};
 StringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 StringWrapper.prototype.$eq = function(other) {
   return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 StringWrapper.prototype.toString = function() {
   return this.my_personal_string_and_you_cannot_have_it;
 }
 // ********** Code for top level **************
 //  ********** Library tree **************
-// ********** Code for Node **************
-function Node() {}
-Node.prototype.hashCode = function() {
+// ********** Code for tree_Node **************
+function tree_Node() {}
+tree_Node.prototype.hashCode = function() {
   return this._hashCode;
 }
-Node.prototype.toString = function() {
+tree_Node.prototype.toString = function() {
   return this.get$debugString();
 }
-// ********** Code for Expression **************
-function Expression() {}
-$inherits(Expression, Node);
-// ********** Code for Statement **************
-function Statement() {}
-$inherits(Statement, Node);
+// ********** Code for tree_Expression **************
+function tree_Expression() {}
+$inherits(tree_Expression, tree_Node);
+// ********** Code for tree_Statement **************
+function tree_Statement() {}
+$inherits(tree_Statement, tree_Node);
 // ********** Code for Invocation **************
 function Invocation(receiver, selector, argumentsNode) {
   this.debugString = "invocation"
   this.receiver = receiver;
   this.selector = selector;
   this.argumentsNode = argumentsNode;
   // Initializers done
 }
-$inherits(Invocation, Expression);
+$inherits(Invocation, tree_Expression);
 Invocation.prototype.get$arguments = function() {
   return this.argumentsNode.nodes;
 }
 Invocation.prototype.get$debugString = function() { return this.debugString; };
 Invocation.prototype.accept = function(visitor) {
   return visitor.visitInvocation(this);
 }
-// ********** Code for NewExpression **************
-function NewExpression() {}
-$inherits(NewExpression, Expression);
-NewExpression.prototype.get$debugString = function() { return this.debugString; };
+// ********** Code for tree_NewExpression **************
+function tree_NewExpression() {}
+$inherits(tree_NewExpression, tree_Expression);
+tree_NewExpression.prototype.get$debugString = function() { return this.debugString; };
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.debugString = "node list"
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
 }
-$inherits(NodeList, Node);
+$inherits(NodeList, tree_Node);
 NodeList.prototype.get$debugString = function() { return this.debugString; };
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 // ********** Code for Block **************
 function Block(beginToken, statements, endToken) {
   this.debugString = "block"
   this.beginToken = beginToken;
   this.statements = statements;
   this.endToken = endToken;
   // Initializers done
 }
-$inherits(Block, Statement);
+$inherits(Block, tree_Statement);
 Block.prototype.get$debugString = function() { return this.debugString; };
 Block.prototype.accept = function(visitor) {
   return visitor.visitBlock(this);
 }
 // ********** Code for FunctionExpression **************
 function FunctionExpression(name, parameters, body, returnType) {
   this.debugString = "function expression"
   this.name = name;
   this.parameters = parameters;
   this.body = body;
   this.returnType = returnType;
   // Initializers done
 }
-$inherits(FunctionExpression, Expression);
+$inherits(FunctionExpression, tree_Expression);
 FunctionExpression.prototype.get$name = function() { return this.name; };
 FunctionExpression.prototype.get$parameters = function() { return this.parameters; };
 FunctionExpression.prototype.get$returnType = function() { return this.returnType; };
 FunctionExpression.prototype.get$debugString = function() { return this.debugString; };
 FunctionExpression.prototype.accept = function(visitor) {
   return visitor.visitFunctionExpression(this);
 }
 // ********** Code for Literal **************
 function Literal(value) {
   this.value = value;
   // Initializers done
 }
-$inherits(Literal, Expression);
+$inherits(Literal, tree_Expression);
 Literal.prototype.get$value = function() { return this.value; };
 Literal.prototype.get$debugString = function() {
   return ("" + this.value + "");
 }
 Literal.prototype.accept = function(visitor) {
   return visitor.visitLiteral(this);
 }
-// ********** Code for Identifier **************
-function Identifier(token) {
+// ********** Code for tree_Identifier **************
+function tree_Identifier(token) {
   this.token = token;
   // Initializers done
 }
-Identifier.fromString$ctor = function(string) {
-  this.token = new StringToken(97, string, -1);
+tree_Identifier.fromString$ctor = function(string) {
+  this.token = new StringToken(97, string, -1.000000/*-1*/);
   // Initializers done
 }
-Identifier.fromString$ctor.prototype = Identifier.prototype;
-$inherits(Identifier, Expression);
-Identifier.prototype.get$debugString = function() {
+tree_Identifier.fromString$ctor.prototype = tree_Identifier.prototype;
+$inherits(tree_Identifier, tree_Expression);
+tree_Identifier.prototype.get$debugString = function() {
   return this.get$name().toString();
 }
-Identifier.prototype.get$name = function() {
+tree_Identifier.prototype.get$name = function() {
   return this.token.get$value();
 }
-Identifier.prototype.accept = function(visitor) {
+tree_Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for Operator **************
 function Operator() {}
 Operator.fromString$ctor = function(string) {
-  Identifier.fromString$ctor.call(this, string);
+  tree_Identifier.fromString$ctor.call(this, string);
   // Initializers done
 }
 Operator.fromString$ctor.prototype = Operator.prototype;
-$inherits(Operator, Identifier);
+$inherits(Operator, tree_Identifier);
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
 // ********** Code for Return **************
 function Return(expression) {
   this.debugString = "return"
   this.expression = expression;
   // Initializers done
 }
-$inherits(Return, Statement);
+$inherits(Return, tree_Statement);
 Return.prototype.get$debugString = function() { return this.debugString; };
 Return.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
-// ********** Code for ExpressionStatement **************
-function ExpressionStatement(expression) {
+// ********** Code for tree_ExpressionStatement **************
+function tree_ExpressionStatement(expression) {
   this.expression = expression;
   // Initializers done
 }
-$inherits(ExpressionStatement, Statement);
-ExpressionStatement.prototype.get$debugString = function() {
+$inherits(tree_ExpressionStatement, tree_Statement);
+tree_ExpressionStatement.prototype.get$debugString = function() {
   return ("" + this.expression.get$debugString() + "");
 }
-ExpressionStatement.prototype.accept = function(visitor) {
+tree_ExpressionStatement.prototype.accept = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 // ********** Code for TypeAnnotation **************
 function TypeAnnotation(typeName) {
   this.typeName = typeName;
   // Initializers done
 }
-$inherits(TypeAnnotation, Node);
+$inherits(TypeAnnotation, tree_Node);
 TypeAnnotation.prototype.get$typeName = function() { return this.typeName; };
 TypeAnnotation.prototype.get$debugString = function() {
   return ("" + this.typeName + "");
 }
 TypeAnnotation.prototype.accept = function(visitor) {
   return visitor.visitTypeAnnotation(this);
 }
 // ********** Code for top level **************
 //  ********** Library ssa **************
 // ********** Code for HInstructionVisitor **************
@@ skipping 127 matching lines @@
   this.inputs = inputs;
   // Initializers done
 }
 HInstruction.prototype.canBeGeneratedAtUseSite = function() {
   return this._canBeGeneratedAtUseSite;
 }
 HInstruction.prototype.setCanBeGeneratedAtUseSite = function() {
   this._canBeGeneratedAtUseSite = true;
 }
 HInstruction.prototype.get$usedBy = function() {
-  if (this._usedBy == null) return const$8/*const <HInstruction>[]*/;
+  if (this._usedBy == null) return const$120/*const <HInstruction>[]*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
   this._usedBy = [];
   for (var i = 0;
    i < this.inputs.length; i++) {
     this.inputs.$index(i).get$usedBy().add(this);
@@ skipping 459 matching lines @@
       if (!(ex instanceof PipelineCancelledException)) throw ex;
       this.pipeline.log(("Parsing failed: " + ex.reason + ""));
     }
   }
   var emptyList = new NodeList(null, LinkFactory.Link$fromList$factory([]));
   if (text == 'void main ( ) { print ( 3 + 4 ) ; }') {
     var three = new Literal(3);
     var four = new Literal(4);
     var plus = ParserStage.newOperator('+');
     var sum = new Invocation(three, plus, ParserStage.newArguments([four]));
-    var print = new ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([sum])));
+    var print = new tree_ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([sum])));
     var body = new Block(null, LinkFactory.Link$factory(print), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body);
     this.pipeline.universe.define(ParserStage.newElement('main', node));
   }
   else if ((text == 'void foo ( ) { return 3 + 4 ; }') && text2 == 'void main ( ) { print ( foo ( ) ) ; }') {
     var foo = new Invocation(null, ParserStage.newIdentifier('foo'), ParserStage.newArguments([]));
-    var print = new ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([foo])));
+    var print = new tree_ExpressionStatement(new Invocation(null, ParserStage.newIdentifier('print'), ParserStage.newArguments([foo])));
     var body = new Block(null, LinkFactory.Link$factory(print), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body);
     this.pipeline.universe.define(ParserStage.newElement('main', node));
     var three = new Literal(3);
     var four = new Literal(4);
     var plus = ParserStage.newOperator('+');
     var sum = new Invocation(three, plus, ParserStage.newArguments([four]));
     var ret = new Return(sum);
     body = new Block(null, LinkFactory.Link$factory(ret), null);
     node = new FunctionExpression(ParserStage.newIdentifier('foo'), emptyList, body);
     this.pipeline.universe.define(ParserStage.newElement('foo', node));
   }
   else if (text == 'void main ( ) { return 3 ; }') {
     var three = new Literal(3);
     var body = new Block(null, LinkFactory.Link$factory(new Return(three)), null);
     var node = new FunctionExpression(ParserStage.newIdentifier('main'), emptyList, body, new TypeAnnotation('void'));
     this.pipeline.universe.define(ParserStage.newElement('main', node));
   }
   else {
     this.pipeline.cancel();
   }
   return input;
 }
 ParserStage.prototype.tokenize = function(text) {
   var tokens = this.pipeline.world.withTiming('[leg] scanning', (function () {
     return new StringScanner(text).tokenize();
   })
   );
   var listener = new Listener(this.pipeline);
-  var parser = new Parser(listener);
+  var parser = new scanner_Parser(listener);
   this.pipeline.world.withTiming('[leg] parsing', (function () {
     return parser.parseUnit(tokens);
   })
   );
   this.pipeline.log(new TokenPrinter(tokens));
   this.pipeline.log(("Parsing " + listener.libraryTagCount + " tags, ") + ("" + listener.classCount + " classes, ") + ("" + listener.interfaceCount + " interfaces, ") + ("" + listener.aliasCount + " typedefs, ") + ("" + listener.topLevelMemberCount + " top-level members"));
   return listener.topLevelElements;
 }
 ParserStage.newArguments = function(expressions) {
   return new NodeList(null, LinkFactory.Link$fromList$factory(expressions), null, null);
 }
 ParserStage.newIdentifier = function(name) {
-  return new Identifier.fromString$ctor(name);
+  return new tree_Identifier.fromString$ctor(name);
 }
 ParserStage.newOperator = function(name) {
   return new Operator.fromString$ctor(name);
 }
 ParserStage.newElement = function(name, node) {
   return new Element(new StringWrapper(name), node);
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
@@ skipping 165 matching lines @@
   return element;
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   this.fail(node);
 }
 ResolverVisitor.prototype.visitInvocation = function(node) {
   var selector = node.selector;
   var target = this.pipeline.universe.find(selector.get$name());
   if (target == null) {
     var name = selector.get$name();
-    if ($eq(name, const$139/*const SourceString('print')*/) || $eq(name, const$140/*const SourceString('+')*/)) {
+    if ($eq(name, const$333/*const SourceString('print')*/) || $eq(name, const$334/*const SourceString('+')*/)) {
     }
     else {
       this.fail(node);
     }
   }
   else {
     this.pipeline.worklist.add(selector.get$name());
   }
   this.visit(node.argumentsNode);
   return null;
@@ skipping 52 matching lines @@
   return this.name.toString();
 }
 // ********** Code for FunctionType **************
 function FunctionType(returnType) {
   this.returnType = returnType;
   // Initializers done
 }
 FunctionType.prototype.get$returnType = function() { return this.returnType; };
 // ********** Code for Types **************
 function Types() {
-  this.VOID = const$134/*const SimpleType(const SourceString('void'))*/
-  this.INT = const$136/*const SimpleType(const SourceString('int'))*/
-  this.DYNAMIC = const$138/*const SimpleType(const SourceString('Dynamic'))*/
+  this.VOID = const$337/*const SimpleType(const SourceString('void'))*/
+  this.INT = const$339/*const SimpleType(const SourceString('int'))*/
+  this.DYNAMIC = const$341/*const SimpleType(const SourceString('Dynamic'))*/
   // Initializers done
 }
 Types.prototype.isSubtype = function(r, s) {
   return r === s || r === this.DYNAMIC || s === this.DYNAMIC;
 }
 Types.prototype.isAssignable = function(r, s) {
   return this.isSubtype(r, s) || this.isSubtype(s, r);
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(pipeline, elements, types, listener) {
@@ skipping 60 matching lines @@
   }
   return this.types.VOID;
 }
 // ********** Code for leg_Script **************
 function leg_Script(text) {
   this.text = text;
   // Initializers done
 }
 leg_Script.prototype.get$text = function() { return this.text; };
 // ********** Code for top level **************
-function compile(world) {
+function leg_compile(world) {
   var file = world.readFile(options.dartScript);
   var script = new leg_Script(file.get$text());
   var pipeline = new WorldPipeline(world, script);
   return pipeline.run();
 }
 //  ********** Library lang **************
 // ********** Code for CodeWriter **************
 function CodeWriter() {
   this._indentation = 0
   this._pendingIndent = false
@@ skipping 12 matching lines @@
   }
 }
 CodeWriter.prototype.comment = function(text) {
   if (this.writeComments) {
     this.writeln(text);
   }
 }
 CodeWriter.prototype.write = function(text) {
   if (text.length == 0) return;
   if (this._pendingIndent) this._indent();
-  if (text.indexOf('\n', 0) != -1) {
+  if (text.indexOf('\n', 0) != -1.000000/*-1*/) {
     var lines = text.split('\n');
     for (var i = 0;
      i < lines.length - 1; i++) {
       this.writeln(lines.$index(i));
     }
     this.write(lines.$index(lines.length - 1));
   }
   else {
     this._buf.add(text);
   }
@@ skipping 276 matching lines @@
   var values = map.getValues();
   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(y.get$span());
     if (spans != 0) return spans;
   }
   if (x.get$span() == null) return 1;
-  if (y.get$span() == null) return -1;
+  if (y.get$span() == null) return -1.000000/*-1*/;
   return x.get$name().compareTo(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember('\$setindex');
   this.genMethod(m.members.$index(0));
   var c = factType.getConstructor('');
@@ skipping 421 matching lines @@
   if ((body instanceof BlockStatement)) {
     var $list = body.body;
     for (var $i = body.body.iterator(); $i.hasNext(); ) {
       var stmt = $i.next();
       stmt.visit(this);
     }
   }
   else {
     if (body != null) body.visit(this);
   }
+  return false;
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
   this._scope = new BlockScope(this, this._scope, reentrant);
 }
 MethodGenerator.prototype._popBlock = function() {
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._makeLambdaMethod = function(name, func) {
   var meth = new MethodMember(name, this.method.declaringType, func);
   meth.isLambda = true;
@@ skipping 17 matching lines @@
 }
 MethodGenerator.prototype.visitVoid = function(node) {
   if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression(node, true);
     value.checkFirstClass(node.span);
     return value;
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
-  var parser = new lang_Parser(node.span.file, false, node.span.start);
+  var parser = new Parser(node.span.file, false, node.span.start);
   this.visitStatementsInBlock(parser.block());
+  return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
   if (node.modifiers != null && node.modifiers.$index(0).kind == 96/*TokenKind.FINAL*/) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type);
   for (var i = 0;
    i < node.names.length; i++) {
@@ skipping 13 matching lines @@
     }
     var val = this._scope.create(name, thisType, node.names.$index(i));
     if (value == null) {
       this.writer.write(('' + val.code + ''));
     }
     else {
       this.writer.write(('' + val.code + ' = ' + value.code + ''));
     }
   }
   this.writer.writeln(';');
+  return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod(name, node);
   var funcValue = this._scope.create(name, meth.get$functionType(), this.method.get$definition());
   meth.generator.writeDefinition(this.writer, null);
+  return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if (node.value == null) {
     this.writer.writeln('return;');
   }
   else {
     if (this.method.get$isConstructor()) {
       world.error('return of value not allowed from constructor', node.span);
     }
     this.writer.writeln(('return ' + this.visitValue(node.value).code + ';'));
   }
+  return true;
 }
 MethodGenerator.prototype.visitThrowStatement = function(node) {
   if (node.value != null) {
     var value = this.visitValue(node.value);
     value.invoke(this.parent, 'toString', node, Arguments.get$EMPTY());
     this.writer.writeln(('\$throw(' + value.code + ');'));
   }
   else {
     var rethrow = this._scope.getRethrow();
     if (rethrow == null) {
       world.error('rethrow outside of catch', node.span);
     }
     else {
       this.writer.writeln(('throw ' + rethrow.code + ';'));
     }
   }
+  return true;
 }
 MethodGenerator.prototype.visitAssertStatement = function(node) {
   var test = this.visitValue(node.test);
   if (options.enableAsserts) {
     var err = world.corelib.types.$index('AssertError');
     err.markUsed();
     this.parent.genMethod(err.getConstructor(''));
     this.parent.genMethod(err.members.$index('toString'));
     var span = node.test.span;
     var line = span.file.getLine(span.start);
     var column = span.file.getColumn(line, span.start);
     this.writer.writeln(('\$assert(' + test.code + ', "' + MethodGenerator._escapeString(span.get$text()) + '",') + (' "' + span.file.filename + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
   }
+  return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
   if (node.label == null) {
     this.writer.writeln('break;');
   }
   else {
     this.writer.writeln(('break ' + node.label.name + ';'));
   }
+  return true;
 }
 MethodGenerator.prototype.visitContinueStatement = function(node) {
   if (node.label == null) {
     this.writer.writeln('continue;');
   }
   else {
     this.writer.writeln(('continue ' + node.label.name + ';'));
   }
+  return true;
 }
 MethodGenerator.prototype.visitIfStatement = function(node) {
   var test = this.visitBool(node.test);
   this.writer.write(('if (' + test.code + ') '));
-  node.trueBranch.visit(this);
+  var exit1 = node.trueBranch.visit(this);
   if (node.falseBranch != null) {
     this.writer.write('else ');
-    node.falseBranch.visit(this);
+    if (node.falseBranch.visit(this) && exit1) {
+      return true;
+    }
   }
+  return false;
 }
 MethodGenerator.prototype.visitWhileStatement = function(node) {
   var test = this.visitBool(node.test);
   this.writer.write(('while (' + test.code + ') '));
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
+  return false;
 }
 MethodGenerator.prototype.visitDoStatement = function(node) {
   this.writer.write('do ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   var test = this.visitBool(node.test);
   this.writer.writeln(('while (' + test.code + ')'));
+  return false;
 }
 MethodGenerator.prototype.visitForStatement = function(node) {
   this._pushBlock(false);
   this.writer.write('for (');
   if (node.init != null) node.init.visit(this);
   else this.writer.write(';');
   if (node.test != null) {
     var test = this.visitBool(node.test);
     this.writer.write((' ' + test.code + '; '));
   }
   else {
     this.writer.write('; ');
   }
   var needsComma = false;
   var $list = node.step;
   for (var $i = 0;$i < $list.length; $i++) {
     var s = $list.$index($i);
     if (needsComma) this.writer.write(', ');
     var sv = this.visitVoid(s);
     this.writer.write(sv.code);
     needsComma = true;
   }
   this.writer.write(') ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   this._popBlock();
+  return false;
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
   var itemType = this.method.resolveType(node.item.type);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
   var item = this._scope.create(itemName, itemType, node.item.name);
   var listVar = list;
   if (list.needsTemp) {
     listVar = this._scope.create('\$list', list.type, null);
@@ skipping 12 matching lines @@
     var iterator = list.invoke(this.parent, 'iterator', node.list, Arguments.get$EMPTY());
     var tmpi = this._scope.create('\$i', iterator.type, null);
     var hasNext = tmpi.invoke(this.parent, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke(this.parent, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
     this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
+  return false;
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
   if (node.catches.length == 1) {
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
     var ex = this._scope.declare(catch_.exception);
@@ skipping 58 matching lines @@
     }
     this._popBlock();
   }
   if (node.finallyBlock != null) {
     this.writer.nextBlock('} finally {');
     this._pushBlock(false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock();
   }
   this.writer.exitBlock('}');
+  return false;
 }
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
   var test = this.visitValue(node.test);
   this.writer.enterBlock(('switch (' + test.code + ') {'));
   var $list = node.cases;
   for (var $i = 0;$i < $list.length; $i++) {
     var case_ = $list.$index($i);
     if (case_.label != null) {
       world.error('unimplemented: labeled case statement', case_.get$span());
     }
     this._pushBlock(false);
     for (var i = 0;
      i < case_.cases.length; i++) {
       var expr = case_.cases.$index(i);
       if (expr == null) {
         if (i < case_.cases.length - 1) {
           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.code + ':'));
       }
     }
     this.writer.enterBlock('');
-    var $list0 = case_.statements;
-    for (var $i0 = case_.statements.iterator(); $i0.hasNext(); ) {
-      var stmt = $i0.next();
-      stmt.visit(this);
-    }
-    if ($ne(case_, node.cases.$index(node.cases.length - 1))) {
+    var caseExits = this._visitAllStatements(case_.statements, false);
+    if ($ne(case_, node.cases.$index(node.cases.length - 1)) && !caseExits) {
       var span = case_.statements.$index(case_.statements.length - 1).get$span();
+      this.writer.writeln(('\$throw(new FallThroughError("' + span.file.filename + '",') + (' ' + span.file.getLine(span.start) + '))'));
     }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
+  return false;
+}
+MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
+  for (var i = 0;
+   i < statementList.length; i++) {
+    var stmt = statementList.$index(i);
+    exits = stmt.visit(this);
+    if ($ne(stmt, statementList.$index(statementList.length - 1)) && exits) {
+      world.warning('unreachable code', statementList.$index(i + 1).get$span());
+    }
+  }
+  return exits;
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
-  var $list = node.body;
-  for (var $i = 0;$i < $list.length; $i++) {
-    var stmt = $list.$index($i);
-    stmt.visit(this);
-  }
+  var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock('}');
   this._popBlock();
+  return exits;
 }
 MethodGenerator.prototype.visitLabeledStatement = function(node) {
   this.writer.writeln(('' + node.name.name + ':'));
   node.body.visit(this);
+  return false;
 }
 MethodGenerator.prototype.visitExpressionStatement = function(node) {
   if ((node.body instanceof VarExpression) || (node.body instanceof ThisExpression)) {
     world.warning('variable used as statement', node.span);
   }
   var value = this.visitVoid(node.body);
   this.writer.writeln(('' + value.code + ';'));
+  return false;
 }
 MethodGenerator.prototype.visitEmptyStatement = function(node) {
   this.writer.writeln(';');
+  return false;
 }
 MethodGenerator.prototype._checkNonStatic = function(node) {
   if (this.method.get$isStatic()) {
     world.warning('not allowed in static method', node.span);
   }
 }
 MethodGenerator.prototype._makeSuperValue = function(node) {
   var parentType = this.method.declaringType.get$parent();
   this._checkNonStatic(node);
   if (parentType == null) {
@@ skipping 126 matching lines @@
     }
     if (x.code == 'null' || y.code == 'null') {
       var op = node.op.toString().substring(0, 2);
       return new Value(null, ('' + x.code + ' ' + op + ' ' + y.code + ''), false, true, false);
     }
     else {
       return new Value(null, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), false, true, false);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
-  if (assignKind == -1) {
+  if (assignKind == -1.000000/*-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) {
       world.internalError(('unimplemented binary op ' + node.op + ''), node.span);
       return;
     }
@@ skipping 285 matching lines @@
     var value = EvaluatedValue.EvaluatedValue$factory(mapImplType, code, code, node.span);
     return this.parent.globalForConst(value, argValues);
   }
   return new Value(mapImplType, code, false, true, false);
 }
 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.code + ' ? ' + trueBranch.code + ' : ' + falseBranch.code + '');
-  return new Value(lang_Type.union(trueBranch.type, falseBranch.type), code, false, true, false);
+  return new Value(Type.union(trueBranch.type, falseBranch.type), code, false, true, false);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type);
   return this._isTest(value, type, node.span, node.isTrue, false);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var body = this.visitValue(node.body);
   if (body.get$isConst()) {
     return EvaluatedValue.EvaluatedValue$factory(body.type, body.get$actualValue(), ('(' + body.canonicalCode + ')'), node.span);
@@ skipping 115 matching lines @@
 Arguments.prototype.getName = function(i) {
   return this.nodes.$index(i).label.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.000000/*-1*/;
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
   return i >= 0 ? this.values.$index(i) : null;
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
       for (var i = 0;
@@ skipping 238 matching lines @@
   this.sources = [];
   this.addSource(this.library.baseSource);
 }
 LibraryVisitor.prototype.get$library = function() { return this.library; };
 LibraryVisitor.prototype.addSourceFromName = function(name) {
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 LibraryVisitor.prototype.addSource = function(source) {
   this.library.sources.add(source);
-  var parser = new lang_Parser(source, options.dietParse, 0);
+  var parser = new Parser(source, options.dietParse, 0);
   var unit = parser.compilationUnit();
   for (var $i = 0;$i < unit.length; $i++) {
     var def = unit.$index($i);
     def.visit(this);
   }
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource(source0);
@@ skipping 1187 matching lines @@
     var arg = $list.$index($i);
     argsCode.add(arg.code);
   }
   return new Value(returnType, ('' + target.code + '.' + this.name + '(' + Strings.join(argsCode, ", ") + ')'), false, true, false);
 }
 MemberSet.prototype.invokeOnVar = function(node, target, args) {
   return this.getVarMember(node, args).invoke(node, target, args);
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
-  var type = lang_Type.union(x.type, y.type);
+  var type = Type.union(x.type, y.type);
   if (x.code == y.code) {
     if ($eq(type, x.type)) {
       return x;
     }
     else if (x.get$isConst() || y.get$isConst()) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       return new Value(type, x.code, x.isSuper && y.isSuper, x.needsTemp || y.needsTemp, x.isType && y.isType);
     }
   }
   else {
     return new Value(type, null, false, true, false);
   }
 }
 MemberSet.prototype.getVarMember = function(node, args) {
   if (world.objectType.varStubs == null) {
     world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = world.objectType.varStubs.$index(stubName);
   if (stub == null) {
     var targets = this.members.filter((function (m) {
       return m.canInvoke(args);
     })
     );
     var returnType = reduce(map(targets, (function (t) {
       return t.get$returnType();
     })
-    ), lang_Type.union);
+    ), Type.union);
     stub = new VarMethodSet(stubName, targets, args, returnType);
     world.objectType.varStubs.$setindex(stubName, stub);
   }
   return stub;
 }
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
@@ skipping 14 matching lines @@
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_0, member) {
       f(member);
     })
     );
   })
   );
 }
 $defineMethod(FactoryMap, "forEach$1", FactoryMap.prototype.forEach);
-// ********** Code for lang_Token **************
-function lang_Token(kind, source, start, end) {
+// ********** Code for Token **************
+function Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
-lang_Token.prototype.get$text = function() {
+Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
-lang_Token.prototype.toString = function() {
+Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($ne(kindText, actualText)) {
     if (actualText.length > 10) {
       actualText = actualText.substring(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return kindText;
   }
 }
-lang_Token.prototype.get$span = function() {
+Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.get$text = function() {
   return this._text;
@@ skipping 79 matching lines @@
     var d = this.start - other.start;
     return d == 0 ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
-  this.depth = -1;
+  this.depth = -1.000000/*-1*/;
   // Initializers done
 }
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
   if (stack != null) newStack.previous = stack;
   return newStack;
 }
@@ skipping 30 matching lines @@
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
-  return new lang_Token(kind, this._source, this._startIndex, this._lang_index);
+  return new Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function() {
   return this._finishToken(64/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
   while (this._lang_index < this._text.length) {
     if (!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++))) {
       this._lang_index--;
       return this.next();
     }
@@ skipping 117 matching lines @@
     else if (ch == 92) {
       if (!this.eatEscapeSequence()) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if (this._interpStack != null) {
-    if (this._interpStack.depth == -1) {
+    if (this._interpStack.depth == -1.000000/*-1*/) {
       this._interpStack.depth = 1;
     }
     else {
       ($0 = this._interpStack).depth = $0.depth + 1;
     }
   }
   return this._finishToken(6/*TokenKind.LBRACE*/);
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
@@ skipping 93 matching lines @@
         else {
           return false;
         }
       }
 
     default:
 
       return true;
 
   }
-  var n = lang_Parser.parseHex(hex);
+  var n = Parser.parseHex(hex);
   return n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
 }
 TokenizerBase.prototype.finishDot = function() {
   if (TokenizerHelpers.isDigit(this._peekChar())) {
     this.eatDigits();
     return this.finishNumberExtra();
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function() {
   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 (this._interpStack != null && this._interpStack.depth == -1) {
+  if (this._interpStack != null && this._interpStack.depth == -1.000000/*-1*/) {
     this._interpStack.depth = 0;
   }
   if (kind == 69/*TokenKind.IDENTIFIER*/) {
     return this._finishToken(69/*TokenKind.IDENTIFIER*/);
   }
   else {
     return this._finishToken(kind);
   }
 }
 // ********** Code for Tokenizer **************
@@ skipping 1150 matching lines @@
     case 55/*TokenKind.GTE*/:
 
       return 10;
 
     case 101/*TokenKind.IS*/:
 
       return 10;
 
     default:
 
-      return -1;
+      return -1.000000/*-1*/;
 
   }
 }
 TokenKind.rawOperatorFromMethod = function(name) {
   switch (name) {
     case '\$bit_not':
 
       return '~';
 
     case '\$bit_or':
@@ skipping 158 matching lines @@
 
     case 57/*TokenKind.SETINDEX*/:
 
       return '\$setindex';
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == 20/*TokenKind.ASSIGN*/) return 0;
   if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
-    return kind + (15)/*(ADD - ASSIGN_ADD)*/;
+    return kind + (15.000000)/*(ADD - ASSIGN_ADD)*/;
   }
-  return -1;
+  return -1.000000/*-1*/;
 }
-// ********** Code for lang_Parser **************
-function lang_Parser(source, diet, startOffset) {
+// ********** Code for Parser **************
+function Parser(source, diet, startOffset) {
   this.source = source;
   this.diet = diet;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
-lang_Parser.prototype.isPrematureEndOfFile = function() {
+Parser.prototype.isPrematureEndOfFile = function() {
   if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
-lang_Parser.prototype._peek = function() {
+Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
-lang_Parser.prototype._lang_next = function() {
+Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
-lang_Parser.prototype._peekKind = function(kind) {
+Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
-lang_Parser.prototype._peekIdentifier = function() {
+Parser.prototype._peekIdentifier = function() {
   return TokenKind.isIdentifier(this._peekToken.kind);
 }
-lang_Parser.prototype._maybeEat = function(kind) {
+Parser.prototype._maybeEat = function(kind) {
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
-lang_Parser.prototype._eat = function(kind) {
+Parser.prototype._eat = function(kind) {
   if (!this._maybeEat(kind)) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
-lang_Parser.prototype._eatSemicolon = function() {
+Parser.prototype._eatSemicolon = function() {
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
-lang_Parser.prototype._errorExpected = function(expected) {
+Parser.prototype._errorExpected = function(expected) {
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
   this._lang_error(message, tok.get$span());
 }
-lang_Parser.prototype._lang_error = function(message, location) {
+Parser.prototype._lang_error = function(message, location) {
   if (location == null) {
     location = this._peekToken.get$span();
   }
   world.fatal(message, location);
 }
-lang_Parser.prototype._skipBlock = function() {
+Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
     var tok = this._lang_next();
     if (tok.kind == 6/*TokenKind.LBRACE*/) {
       depth += 1;
     }
     else if (tok.kind == 7/*TokenKind.RBRACE*/) {
       depth -= 1;
       if (depth == 0) return;
     }
     else if (tok.kind == 1/*TokenKind.END_OF_FILE*/) {
       this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
-lang_Parser.prototype._makeSpan = function(start) {
+Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
-lang_Parser.prototype.compilationUnit = function() {
+Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while (this._peekKind(12/*TokenKind.HASH*/)) {
     ret.add(this.directive());
   }
   while (!this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
     ret.add(this.topLevelDefinition());
   }
   return ret;
 }
-lang_Parser.prototype.directive = function() {
+Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
-lang_Parser.prototype.topLevelDefinition = function() {
+Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
     case 72/*TokenKind.CLASS*/:
 
       return this.classDefinition(72/*TokenKind.CLASS*/);
 
     case 78/*TokenKind.INTERFACE*/:
 
       return this.classDefinition(78/*TokenKind.INTERFACE*/);
 
     case 86/*TokenKind.TYPEDEF*/:
 
       return this.functionTypeAlias();
 
     default:
 
       return this.declaration();
 
   }
 }
-lang_Parser.prototype.classDefinition = function(kind) {
+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*/)) {
     typeParams = this.typeParameters();
   }
   var _extends = null;
   if (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
     _extends = this.typeList();
@@ skipping 15 matching lines @@
     while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
       if (this.isPrematureEndOfFile()) break;
       body.add(this.declaration());
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
   return new TypeDefinition(kind == 72/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
-lang_Parser.prototype.functionTypeAlias = function() {
+Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(86/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
   var func = new FunctionDefinition(null, di.type, di.get$name(), formals, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
-lang_Parser.prototype.initializers = function() {
+Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add(this.expression());
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   this._inInitializers = false;
   return ret;
 }
-lang_Parser.prototype.functionBody = function(inExpression) {
+Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if (this._maybeEat(9/*TokenKind.ARROW*/)) {
     var expr = this.expression();
     if (!inExpression) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     if (this.diet) {
@@ skipping 14 matching lines @@
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
         return this.functionBody(inExpression);
       }
     }
   }
   this._lang_error('Expected function body (neither { nor => found)');
 }
-lang_Parser.prototype.finishField = function(start, modifiers, type, name, value) {
+Parser.prototype.finishField = function(start, modifiers, type, name, value) {
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       values.add(this.expression());
     }
     else {
       values.add(null);
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan(start));
 }
-lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
+Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if (this._maybeEat(8/*TokenKind.COLON*/)) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
       if (di.get$name() == null) {
@@ skipping 12 matching lines @@
 
       return this.finishField(start, modifiers, di.type, di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
-lang_Parser.prototype.declaration = function() {
+Parser.prototype.declaration = function() {
   var start = this._peekToken.start;
   if (this._peekKind(74/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(true));
 }
-lang_Parser.prototype.factoryConstructorDeclaration = function() {
+Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add(this.identifier());
   }
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   else if (typeParams == null) {
     if (names.length > 1) {
       name = names.removeLast();
     }
     else {
-      name = new lang_Identifier('', names.$index(0).get$span());
+      name = new Identifier('', names.$index(0).get$span());
     }
   }
   else {
-    name = new lang_Identifier('', names.$index(0).get$span());
+    name = new Identifier('', names.$index(0).get$span());
   }
   if (names.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());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
-lang_Parser.prototype.statement = function() {
+Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 87/*TokenKind.BREAK*/:
 
       return this.breakStatement();
 
     case 91/*TokenKind.CONTINUE*/:
 
       return this.continueStatement();
 
     case 104/*TokenKind.RETURN*/:
@@ skipping 47 matching lines @@
     case 111/*TokenKind.VAR*/:
 
       return this.declaration();
 
     default:
 
       return this.finishExpressionAsStatement(this.expression());
 
   }
 }
-lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
+Parser.prototype.finishExpressionAsStatement = function(expr) {
   var start = expr.get$span().start;
   if (this._maybeEat(8/*TokenKind.COLON*/)) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
   if ((expr instanceof LambdaExpression)) {
     if (!(expr.func.body instanceof BlockStatement)) {
       this._eatSemicolon();
       expr.func.span = this._makeSpan(start);
     }
@@ skipping 16 matching lines @@
     var gt = this._finishTypeArguments(baseType, 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       value = this.expression();
     }
     return this.finishField(expr.get$span().start, null, gt, name, value);
   }
   else {
     this._eatSemicolon();
-    return new lang_ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
+    return new ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
   }
 }
-lang_Parser.prototype.testCondition = function() {
+Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return ret;
 }
-lang_Parser.prototype.block = function() {
+Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     if (this.isPrematureEndOfFile()) break;
     stmts.add(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
 }
-lang_Parser.prototype.emptyStatement = function() {
+Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
-lang_Parser.prototype.ifStatement = function() {
+Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.IF*/);
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
   if (this._maybeEat(94/*TokenKind.ELSE*/)) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
-lang_Parser.prototype.whileStatement = function() {
+Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
   this._eat(113/*TokenKind.WHILE*/);
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
-lang_Parser.prototype.doStatement = function() {
+Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
   this._eat(93/*TokenKind.DO*/);
   var body = this.statement();
   this._eat(113/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
-lang_Parser.prototype.forStatement = function() {
+Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(98/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
   if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
   if (!this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     step.add(this.expression());
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       step.add(this.expression());
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
-lang_Parser.prototype.forInitializerStatement = function(start) {
+Parser.prototype.forInitializerStatement = function(start) {
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     return null;
   }
   else {
     var init = this.expression();
     if (this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/)) {
       this._eat(11/*TokenKind.COMMA*/);
       var baseType = this._makeType(init.x);
       var typeArgs = [this._makeType(init.y)];
       var gt = this._finishTypeArguments(baseType, 0, typeArgs);
       var name = this.identifier();
       init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().start));
     }
     if (this._maybeEat(100/*TokenKind.IN*/)) {
       return this._finishForIn(start, this._makeDeclaredIdentifier(init));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
-lang_Parser.prototype._finishForIn = function(start, di) {
+Parser.prototype._finishForIn = function(start, di) {
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.statement();
   return new ForInStatement(di, expr, body, this._makeSpan(start));
 }
-lang_Parser.prototype.tryStatement = function() {
+Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
   this._eat(110/*TokenKind.TRY*/);
   var body = this.block();
   var catches = [];
   while (this._peekKind(89/*TokenKind.CATCH*/)) {
     catches.add(this.catchNode());
   }
   var finallyBlock = null;
   if (this._maybeEat(97/*TokenKind.FINALLY*/)) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
-lang_Parser.prototype.catchNode = function() {
+Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
   this._eat(89/*TokenKind.CATCH*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var exc = this.declaredIdentifier(false);
   var trace = null;
   if (this._maybeEat(11/*TokenKind.COMMA*/)) {
     trace = this.declaredIdentifier(false);
   }
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
-lang_Parser.prototype.switchStatement = function() {
+Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(106/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     cases.add(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
-lang_Parser.prototype._peekCaseEnd = function() {
+Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
   return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 88/*TokenKind.CASE*/) || $eq(kind, 92/*TokenKind.DEFAULT*/);
 }
-lang_Parser.prototype.caseNode = function() {
+Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if (this._peekIdentifier()) {
+    label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
-    label = this.identifier();
   }
   var cases = [];
   while (true) {
     if (this._maybeEat(88/*TokenKind.CASE*/)) {
       cases.add(this.expression());
       this._eat(8/*TokenKind.COLON*/);
     }
     else if (this._maybeEat(92/*TokenKind.DEFAULT*/)) {
       cases.add(null);
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
   if (cases.length == 0) {
     this._lang_error('case or default');
   }
   var stmts = [];
   while (!this._peekCaseEnd()) {
     if (this.isPrematureEndOfFile()) break;
     stmts.add(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
-lang_Parser.prototype.returnStatement = function() {
+Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(104/*TokenKind.RETURN*/);
   var expr;
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ReturnStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.throwStatement = function() {
+Parser.prototype.throwStatement = function() {
   var start = this._peekToken.start;
   this._eat(108/*TokenKind.THROW*/);
   var expr;
   if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.assertStatement = function() {
+Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
   this._eat(71/*TokenKind.ASSERT*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
-lang_Parser.prototype.breakStatement = function() {
+Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.BREAK*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
-lang_Parser.prototype.continueStatement = function() {
+Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
   this._eat(91/*TokenKind.CONTINUE*/);
   var name = null;
   if (this._peekIdentifier()) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
-lang_Parser.prototype.expression = function() {
+Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
-lang_Parser.prototype._makeType = function(expr) {
+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.self);
     if (type.names == null) {
       type.names = [expr.get$name()];
     }
     else {
       type.names.add(expr.get$name());
     }
     type.span = expr.get$span();
     return type;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
-lang_Parser.prototype.infixExpression = function(precedence) {
+Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
-lang_Parser.prototype._finishDeclaredId = function(type) {
+Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().start)));
 }
-lang_Parser.prototype._fixAsType = function(x) {
+Parser.prototype._fixAsType = function(x) {
   if (this._maybeEat(53/*TokenKind.GT*/)) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     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 type;
     if (firstParam.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 {
       this._eat(53/*TokenKind.GT*/);
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
-lang_Parser.prototype.finishInfixExpression = function(x, precedence) {
+Parser.prototype.finishInfixExpression = function(x, precedence) {
   while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if (prec >= precedence) {
       if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
         if (this._isBin(x, 52/*TokenKind.LT*/)) {
           return this._fixAsType(x);
         }
       }
       var op = this._lang_next();
@@ skipping 12 matching lines @@
       else {
         x = new BinaryExpression(op, x, y, this._makeSpan(x.span.start));
       }
     }
     else {
       break;
     }
   }
   return x;
 }
-lang_Parser.prototype._isPrefixUnaryOperator = function(kind) {
+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*/:
 
       return true;
 
     default:
 
       return false;
 
   }
 }
-lang_Parser.prototype.unaryExpression = function() {
+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));
   }
   return this.finishPostfixExpression(this.primary());
 }
-lang_Parser.prototype.argument = function() {
+Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
   if (this._maybeEat(15/*TokenKind.ELLIPSIS*/)) {
-    label = new lang_Identifier('...', this._makeSpan(start));
+    label = new Identifier('...', this._makeSpan(start));
   }
   expr = this.expression();
   if (label == null && this._maybeEat(8/*TokenKind.COLON*/)) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
-lang_Parser.prototype.arguments = function() {
+Parser.prototype.arguments = function() {
   var args = [];
   this._eat(2/*TokenKind.LPAREN*/);
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     do {
       args.add(this.argument());
     }
     while (this._maybeEat(11/*TokenKind.COMMA*/))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
-lang_Parser.prototype.get$arguments = function() {
-  return lang_Parser.prototype.arguments.bind(this);
+Parser.prototype.get$arguments = function() {
+  return Parser.prototype.arguments.bind(this);
 }
-lang_Parser.prototype.finishPostfixExpression = function(expr) {
+Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       return this.finishPostfixExpression(new CallExpression(expr, this.arguments(), this._makeSpan(expr.get$span().start)));
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
       var index = this.expression();
       this._eat(5/*TokenKind.RBRACK*/);
@@ skipping 23 matching lines @@
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
-lang_Parser.prototype._isBin = function(expr, kind) {
+Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
-lang_Parser.prototype._boolTypeRef = function(span) {
+Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.boolType);
 }
-lang_Parser.prototype._numTypeRef = function(span) {
+Parser.prototype._numTypeRef = function(span) {
   return new TypeReference(span, world.numType);
 }
-lang_Parser.prototype._stringTypeRef = function(span) {
+Parser.prototype._stringTypeRef = function(span) {
   return new TypeReference(span, world.stringType);
 }
-lang_Parser.prototype.primary = function() {
+Parser.prototype.primary = function() {
   var start = this._peekToken.start;
   switch (this._peek()) {
     case 107/*TokenKind.THIS*/:
 
       this._eat(107/*TokenKind.THIS*/);
       return new ThisExpression(this._makeSpan(start));
 
     case 105/*TokenKind.SUPER*/:
 
       this._eat(105/*TokenKind.SUPER*/);
@@ skipping 44 matching lines @@
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
     case 95/*TokenKind.FALSE*/:
 
       this._eat(95/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
     case 61/*TokenKind.HEX_NUMBER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(Parser.parseHex(t.get$text().substring(2)), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 60/*TokenKind.NUMBER*/:
 
       var t = this._lang_next();
       return new LiteralExpression(Math.parseDouble(t.get$text()), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
 
@@ skipping 13 matching lines @@
 
     default:
 
       if (!this._peekIdentifier()) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
-lang_Parser.prototype.stringInterpolation = function() {
+Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while (this._peekKind(65/*TokenKind.INCOMPLETE_STRING*/)) {
     var token = this._lang_next();
     var text = token.get$text();
     if (startQuote == null) {
       if (isMultilineString(text)) {
         endQuote = text.substring(0, 3);
         startQuote = endQuote + '\n';
@@ skipping 18 matching lines @@
   }
   var tok = this._lang_next();
   if (tok.kind != 58/*TokenKind.STRING*/) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
   lits.add(this.makeStringLiteral(text, tok.get$span()));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef(span), '\$\$\$', span);
 }
-lang_Parser.prototype.makeStringLiteral = function(text, span) {
+Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
-lang_Parser.prototype.stringLiteralExpr = function() {
+Parser.prototype.stringLiteralExpr = function() {
   var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
-lang_Parser.prototype.maybeStringLiteral = function() {
+Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($eq(kind, 58/*TokenKind.STRING*/)) {
     return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
     this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($eq(kind, 65/*TokenKind.INCOMPLETE_STRING*/)) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
-lang_Parser.prototype._parenOrLambda = function() {
+Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
   if (!this._inInitializers && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     if (args.length == 1) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
       this._lang_error('unexpected comma expression');
       return args.$index(0).get$value();
     }
   }
 }
-lang_Parser.prototype._typeAsIdentifier = function(type) {
+Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
-lang_Parser.prototype._specialIdentifier = function(includeOperators) {
+Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
       this._lang_error('rest no longer supported', this._previousToken);
       name = this.identifier().get$name();
       break;
 
@@ skipping 46 matching lines @@
           this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
-  return new lang_Identifier(name, this._makeSpan(start));
+  return new Identifier(name, this._makeSpan(start));
 }
-lang_Parser.prototype.declaredIdentifier = function(includeOperators) {
+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);
     name = this._specialIdentifier(includeOperators);
     if (name == null) {
       if (this._peekIdentifier()) {
         name = this.identifier();
       }
       else if ((myType instanceof NameTypeReference) && myType.names == null) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
-lang_Parser._hexDigit = function(c) {
+Parser._hexDigit = function(c) {
   if (c >= 48 && c <= 57) {
     return c - 48;
   }
   else if (c >= 97 && c <= 102) {
     return c - 87;
   }
   else if (c >= 65 && c <= 70) {
     return c - 55;
   }
   else {
-    return -1;
+    return -1.000000/*-1*/;
   }
 }
-lang_Parser.parseHex = function(hex) {
+Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
-    var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
+    var digit = Parser._hexDigit(hex.charCodeAt(i));
     result = (result << 4) + digit;
   }
   return result;
 }
-lang_Parser.prototype.finishNewExpression = function(start, isConst) {
+Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   var args = this.arguments();
-  return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
+  return new NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
-lang_Parser.prototype.finishListLiteral = function(start, isConst, type) {
+Parser.prototype.finishListLiteral = function(start, isConst, type) {
   if (this._maybeEat(56/*TokenKind.INDEX*/)) {
     return new ListExpression(isConst, type, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
   while (!this._maybeEat(5/*TokenKind.RBRACK*/)) {
     if (this.isPrematureEndOfFile()) break;
     values.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type, values, this._makeSpan(start));
 }
-lang_Parser.prototype.finishMapLiteral = function(start, isConst, type) {
+Parser.prototype.finishMapLiteral = function(start, isConst, type) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     if (this.isPrematureEndOfFile()) break;
     items.add(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type, items, this._makeSpan(start));
 }
-lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
+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*/)) {
     return this.finishListLiteral(start, isConst, genericType);
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     return this.finishMapLiteral(start, isConst, genericType);
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
-lang_Parser.prototype._readModifiers = function() {
+Parser.prototype._readModifiers = function() {
   var modifiers = null;
   while (true) {
     switch (this._peek()) {
       case 85/*TokenKind.STATIC*/:
       case 96/*TokenKind.FINAL*/:
       case 90/*TokenKind.CONST*/:
       case 70/*TokenKind.ABSTRACT*/:
       case 74/*TokenKind.FACTORY*/:
 
         if (modifiers == null) modifiers = [];
         modifiers.add(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
-lang_Parser.prototype.typeParameter = function() {
+Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
     myType = this.type(1);
   }
   return new TypeParameter(name, myType, this._makeSpan(start));
 }
-lang_Parser.prototype.typeParameters = function() {
+Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add(tp);
     if ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
       closed = true;
       break;
     }
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   if (!closed) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
-lang_Parser.prototype.get$typeParameters = function() {
-  return lang_Parser.prototype.typeParameters.bind(this);
+Parser.prototype.get$typeParameters = function() {
+  return Parser.prototype.typeParameters.bind(this);
 }
-lang_Parser.prototype._eatClosingAngle = function(depth) {
+Parser.prototype._eatClosingAngle = function(depth) {
   if (this._maybeEat(53/*TokenKind.GT*/)) {
     return depth;
   }
   else if (depth > 0 && this._maybeEat(40/*TokenKind.SAR*/)) {
     return depth - 1;
   }
   else if (depth > 1 && this._maybeEat(41/*TokenKind.SHR*/)) {
     return depth - 2;
   }
   else {
     this._errorExpected('>');
     return depth;
   }
 }
-lang_Parser.prototype.addTypeArguments = function(baseType, depth) {
+Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat(52/*TokenKind.LT*/);
   return this._finishTypeArguments(baseType, depth, []);
 }
-lang_Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
-  var delta = -1;
+Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
+  var delta = -1.000000/*-1*/;
   do {
     var myType = this.type(depth + 1);
     types.add(myType);
     if ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
       delta = depth - myType.depth;
       break;
     }
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   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);
 }
-lang_Parser.prototype.typeList = function() {
+Parser.prototype.typeList = function() {
   var types = [];
   do {
     types.add(this.type(0));
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   return types;
 }
-lang_Parser.prototype.type = function(depth) {
+Parser.prototype.type = function(depth) {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
     case 112/*TokenKind.VOID*/:
 
       return new TypeReference(this._lang_next().get$span(), world.voidType);
 
@@ skipping 19 matching lines @@
     names.add(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
   if (this._peekKind(52/*TokenKind.LT*/)) {
     return this.addTypeArguments(typeRef, depth);
   }
   else {
     return typeRef;
   }
 }
-lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
+Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.type;
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
     if (!inOptionalBlock) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
-lang_Parser.prototype.formalParameterList = function() {
+Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
       inOptionalBlock = true;
     }
     formals.add(this.formalParameter(inOptionalBlock));
     while (this._maybeEat(11/*TokenKind.COMMA*/)) {
       if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
         if (inOptionalBlock) {
           this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add(this.formalParameter(inOptionalBlock));
     }
     if (inOptionalBlock) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
-lang_Parser.prototype.identifier = function() {
+Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!TokenKind.isIdentifier(tok.kind)) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
-  return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
+  return new Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
-lang_Parser.prototype._makeFunction = function(expr, body) {
+Parser.prototype._makeFunction = function(expr, body) {
   var name, type;
   if ((expr instanceof CallExpression)) {
     if ((expr.target instanceof VarExpression)) {
       name = expr.target.get$name();
       type = null;
     }
     else if ((expr.target instanceof DeclaredIdentifier)) {
       name = expr.target.get$name();
       type = expr.target.type;
     }
     else {
       this._lang_error('bad function');
     }
     var formals = this._makeFormals(expr.get$arguments());
     var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
     var func = new FunctionDefinition(null, type, name, formals, null, body, span);
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._lang_error('expected function');
   }
 }
-lang_Parser.prototype._makeFormal = function(expr) {
+Parser.prototype._makeFormal = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
   }
   else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier))) {
     var di = expr.x;
     return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
   }
   else if (this._isBin(expr, 52/*TokenKind.LT*/)) {
     return null;
   }
   else if ((expr instanceof ListExpression)) {
     return this._makeFormalsFromList(expr);
   }
   else {
     this._lang_error('expected formal', expr.get$span());
   }
 }
-lang_Parser.prototype._makeFormalsFromList = function(expr) {
+Parser.prototype._makeFormalsFromList = function(expr) {
   if (expr.get$isConst()) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
   else if ($ne(expr.type, null)) {
     this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
   }
   return this._makeFormalsFromExpressions(expr.values, false);
 }
-lang_Parser.prototype._makeFormals = function(arguments) {
+Parser.prototype._makeFormals = function(arguments) {
   var expressions = [];
   for (var i = 0;
    i < arguments.length; i++) {
     var arg = arguments.$index(i);
     if (arg.label != null) {
       this._lang_error('expected formal, but found ":"');
     }
     expressions.add(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
-lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
+Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var formals = [];
   for (var i = 0;
    i < expressions.length; i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if (formal == null) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
       while (i < expressions.length) {
         var expr = expressions.$index(i++);
@@ skipping 22 matching lines @@
       if (!allowOptional) {
         this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
       }
     }
     else {
       formals.add(formal);
     }
   }
   return formals;
 }
-lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
+Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
     this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
-lang_Parser.prototype._makeLabel = function(expr) {
+Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
-// ********** Code for lang_Node **************
-function lang_Node(span) {
+// ********** Code for Node **************
+function Node(span) {
   this.span = span;
   // Initializers done
 }
-lang_Node.prototype.get$span = function() { return this.span; };
-lang_Node.prototype.set$span = function(value) { return this.span = value; };
+Node.prototype.get$span = function() { return this.span; };
+Node.prototype.set$span = function(value) { return this.span = value; };
 // ********** Code for Definition **************
 function Definition(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(Definition, lang_Statement);
+$inherits(Definition, Statement);
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
-// ********** Code for lang_Statement **************
-function lang_Statement(span) {
-  lang_Node.call(this, span);
+// ********** Code for Statement **************
+function Statement(span) {
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Statement, lang_Node);
-// ********** Code for lang_Expression **************
-function lang_Expression(span) {
-  lang_Node.call(this, span);
+$inherits(Statement, Node);
+// ********** Code for Expression **************
+function Expression(span) {
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Expression, lang_Node);
+$inherits(Expression, Node);
 // ********** Code for TypeReference **************
 function TypeReference(span, type) {
   this.type = type;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(TypeReference, lang_Node);
+$inherits(TypeReference, Node);
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 // ********** Code for TreeOutput **************
 function TreeOutput() {}
 TreeOutput.prototype.write = function(s) {
   for (var i = 0;
    i < this.depth; i++) {
     this.buf.add(' ');
   }
   this.buf.add(s);
 }
 TreeOutput.prototype.writeln = function(s) {
   this.write(s);
   this.buf.add('\n');
 }
 TreeOutput.prototype.heading = function(name, span) {
   this.buf.add(name);
   this.buf.add('\n');
 }
 TreeOutput.prototype.toValue = function(value) {
   if (value == null) return 'null';
-  else if ((value instanceof lang_Identifier)) return value.get$name();
+  else if ((value instanceof Identifier)) return value.get$name();
   else return value.toString();
 }
 TreeOutput.prototype.writeNode = function(label, node) {
   this.write(label + ': ');
   this.depth += 1;
   if (node != null) node.visit(this.printer);
   else this.writeln('null');
   this.depth -= 1;
 }
 TreeOutput.prototype.writeValue = function(label, value) {
@@ skipping 110 matching lines @@
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 // ********** Code for ReturnStatement **************
 function ReturnStatement(value, span) {
   this.value = value;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ReturnStatement, lang_Statement);
+$inherits(ReturnStatement, Statement);
 ReturnStatement.prototype.get$value = function() { return this.value; };
 ReturnStatement.prototype.set$value = function(value) { return this.value = value; };
 ReturnStatement.prototype.visit = function(visitor) {
   return visitor.visitReturnStatement(this);
 }
 // ********** Code for ThrowStatement **************
 function ThrowStatement(value, span) {
   this.value = value;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ThrowStatement, lang_Statement);
+$inherits(ThrowStatement, Statement);
 ThrowStatement.prototype.get$value = function() { return this.value; };
 ThrowStatement.prototype.set$value = function(value) { return this.value = value; };
 ThrowStatement.prototype.visit = function(visitor) {
   return visitor.visitThrowStatement(this);
 }
 // ********** Code for AssertStatement **************
 function AssertStatement(test, span) {
   this.test = test;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(AssertStatement, lang_Statement);
+$inherits(AssertStatement, Statement);
 AssertStatement.prototype.visit = function(visitor) {
   return visitor.visitAssertStatement(this);
 }
 // ********** Code for BreakStatement **************
 function BreakStatement(label, span) {
   this.label = label;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(BreakStatement, lang_Statement);
+$inherits(BreakStatement, Statement);
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 // ********** Code for ContinueStatement **************
 function ContinueStatement(label, span) {
   this.label = label;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ContinueStatement, lang_Statement);
+$inherits(ContinueStatement, Statement);
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 // ********** Code for IfStatement **************
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(IfStatement, lang_Statement);
+$inherits(IfStatement, Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 // ********** Code for WhileStatement **************
 function WhileStatement(test, body, span) {
   this.test = test;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(WhileStatement, lang_Statement);
+$inherits(WhileStatement, Statement);
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 // ********** Code for DoStatement **************
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(DoStatement, lang_Statement);
+$inherits(DoStatement, Statement);
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 // ********** Code for ForStatement **************
 function ForStatement(init, test, step, body, span) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ForStatement, lang_Statement);
+$inherits(ForStatement, Statement);
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 // ********** Code for ForInStatement **************
 function ForInStatement(item, list, body, span) {
   this.item = item;
   this.list = list;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(ForInStatement, lang_Statement);
+$inherits(ForInStatement, Statement);
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 // ********** Code for TryStatement **************
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(TryStatement, lang_Statement);
+$inherits(TryStatement, Statement);
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 // ********** Code for SwitchStatement **************
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(SwitchStatement, lang_Statement);
+$inherits(SwitchStatement, Statement);
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 // ********** Code for BlockStatement **************
 function BlockStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(BlockStatement, lang_Statement);
+$inherits(BlockStatement, Statement);
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 // ********** Code for LabeledStatement **************
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(LabeledStatement, lang_Statement);
+$inherits(LabeledStatement, Statement);
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
 LabeledStatement.prototype.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
-// ********** Code for lang_ExpressionStatement **************
-function lang_ExpressionStatement(body, span) {
+// ********** Code for ExpressionStatement **************
+function ExpressionStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(lang_ExpressionStatement, lang_Statement);
-lang_ExpressionStatement.prototype.visit = function(visitor) {
+$inherits(ExpressionStatement, Statement);
+ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 // ********** Code for EmptyStatement **************
 function EmptyStatement(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(EmptyStatement, lang_Statement);
+$inherits(EmptyStatement, Statement);
 EmptyStatement.prototype.visit = function(visitor) {
   return visitor.visitEmptyStatement(this);
 }
 // ********** Code for DietStatement **************
 function DietStatement(span) {
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(DietStatement, lang_Statement);
+$inherits(DietStatement, Statement);
 DietStatement.prototype.visit = function(visitor) {
   return visitor.visitDietStatement(this);
 }
 // ********** Code for NativeStatement **************
 function NativeStatement(body, span) {
   this.body = body;
-  lang_Statement.call(this, span);
+  Statement.call(this, span);
   // Initializers done
 }
-$inherits(NativeStatement, lang_Statement);
+$inherits(NativeStatement, Statement);
 NativeStatement.prototype.visit = function(visitor) {
   return visitor.visitNativeStatement(this);
 }
 // ********** Code for LambdaExpression **************
 function LambdaExpression(func, span) {
   this.func = func;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(LambdaExpression, lang_Expression);
+$inherits(LambdaExpression, Expression);
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(CallExpression, lang_Expression);
+$inherits(CallExpression, Expression);
 CallExpression.prototype.get$arguments = function() { return this.arguments; };
 CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(IndexExpression, lang_Expression);
+$inherits(IndexExpression, Expression);
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 // ********** Code for BinaryExpression **************
 function BinaryExpression(op, x, y, span) {
   this.op = op;
   this.x = x;
   this.y = y;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(BinaryExpression, lang_Expression);
+$inherits(BinaryExpression, Expression);
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(UnaryExpression, lang_Expression);
+$inherits(UnaryExpression, Expression);
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 // ********** Code for PostfixExpression **************
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(PostfixExpression, lang_Expression);
+$inherits(PostfixExpression, Expression);
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
-// ********** Code for lang_NewExpression **************
-function lang_NewExpression(isConst, type, name, arguments, span) {
+// ********** Code for NewExpression **************
+function NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(lang_NewExpression, lang_Expression);
-lang_NewExpression.prototype.get$isConst = function() { return this.isConst; };
-lang_NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
-lang_NewExpression.prototype.get$name = function() { return this.name; };
-lang_NewExpression.prototype.set$name = function(value) { return this.name = value; };
-lang_NewExpression.prototype.get$arguments = function() { return this.arguments; };
-lang_NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
-lang_NewExpression.prototype.visit = function(visitor) {
+$inherits(NewExpression, Expression);
+NewExpression.prototype.get$isConst = function() { return this.isConst; };
+NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
+NewExpression.prototype.get$name = function() { return this.name; };
+NewExpression.prototype.set$name = function(value) { return this.name = value; };
+NewExpression.prototype.get$arguments = function() { return this.arguments; };
+NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
+NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 // ********** Code for ListExpression **************
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ListExpression, lang_Expression);
+$inherits(ListExpression, Expression);
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 // ********** Code for MapExpression **************
 function MapExpression(isConst, type, items, span) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(MapExpression, lang_Expression);
+$inherits(MapExpression, Expression);
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 // ********** Code for ConditionalExpression **************
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ConditionalExpression, lang_Expression);
+$inherits(ConditionalExpression, Expression);
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 // ********** Code for IsExpression **************
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(IsExpression, lang_Expression);
+$inherits(IsExpression, Expression);
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 // ********** Code for ParenExpression **************
 function ParenExpression(body, span) {
   this.body = body;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ParenExpression, lang_Expression);
+$inherits(ParenExpression, Expression);
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 // ********** Code for DotExpression **************
 function DotExpression(self, name, span) {
   this.self = self;
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(DotExpression, lang_Expression);
+$inherits(DotExpression, Expression);
 DotExpression.prototype.get$name = function() { return this.name; };
 DotExpression.prototype.set$name = function(value) { return this.name = value; };
 DotExpression.prototype.visit = function(visitor) {
   return visitor.visitDotExpression(this);
 }
 // ********** Code for VarExpression **************
 function VarExpression(name, span) {
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(VarExpression, lang_Expression);
+$inherits(VarExpression, Expression);
 VarExpression.prototype.get$name = function() { return this.name; };
 VarExpression.prototype.set$name = function(value) { return this.name = value; };
 VarExpression.prototype.visit = function(visitor) {
   return visitor.visitVarExpression(this);
 }
 // ********** Code for ThisExpression **************
 function ThisExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(ThisExpression, lang_Expression);
+$inherits(ThisExpression, Expression);
 ThisExpression.prototype.visit = function(visitor) {
   return visitor.visitThisExpression(this);
 }
 // ********** Code for SuperExpression **************
 function SuperExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(SuperExpression, lang_Expression);
+$inherits(SuperExpression, Expression);
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 // ********** Code for NullExpression **************
 function NullExpression(span) {
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(NullExpression, lang_Expression);
+$inherits(NullExpression, Expression);
 NullExpression.prototype.visit = function(visitor) {
   return visitor.visitNullExpression(this);
 }
 // ********** Code for LiteralExpression **************
 function LiteralExpression(value, type, text, span) {
   this.value = value;
   this.type = type;
   this.text = text;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(LiteralExpression, lang_Expression);
+$inherits(LiteralExpression, Expression);
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
 LiteralExpression.prototype.get$text = function() { return this.text; };
 LiteralExpression.prototype.set$text = function(value) { return this.text = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 // ********** Code for NameTypeReference **************
 function NameTypeReference(isFinal, name, names, span) {
   this.isFinal = isFinal;
@@ skipping 28 matching lines @@
   // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(ArgumentNode, lang_Node);
+$inherits(ArgumentNode, Node);
 ArgumentNode.prototype.get$value = function() { return this.value; };
 ArgumentNode.prototype.set$value = function(value) { return this.value = value; };
 ArgumentNode.prototype.visit = function(visitor) {
   return visitor.visitArgumentNode(this);
 }
 // ********** Code for FormalNode **************
 function FormalNode(isThis, isRest, type, name, value, span) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
   this.name = name;
   this.value = value;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(FormalNode, lang_Node);
+$inherits(FormalNode, Node);
 FormalNode.prototype.get$name = function() { return this.name; };
 FormalNode.prototype.set$name = function(value) { return this.name = value; };
 FormalNode.prototype.get$value = function() { return this.value; };
 FormalNode.prototype.set$value = function(value) { return this.value = value; };
 FormalNode.prototype.visit = function(visitor) {
   return visitor.visitFormalNode(this);
 }
 // ********** Code for CatchNode **************
 function CatchNode(exception, trace, body, span) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(CatchNode, lang_Node);
+$inherits(CatchNode, Node);
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 // ********** Code for CaseNode **************
 function CaseNode(label, cases, statements, span) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(CaseNode, lang_Node);
+$inherits(CaseNode, Node);
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 // ********** Code for TypeParameter **************
 function TypeParameter(name, extendsType, span) {
   this.name = name;
   this.extendsType = extendsType;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(TypeParameter, lang_Node);
+$inherits(TypeParameter, Node);
 TypeParameter.prototype.get$name = function() { return this.name; };
 TypeParameter.prototype.set$name = function(value) { return this.name = value; };
 TypeParameter.prototype.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
-// ********** Code for lang_Identifier **************
-function lang_Identifier(name, span) {
+// ********** Code for Identifier **************
+function Identifier(name, span) {
   this.name = name;
-  lang_Node.call(this, span);
+  Node.call(this, span);
   // Initializers done
 }
-$inherits(lang_Identifier, lang_Node);
-lang_Identifier.prototype.get$name = function() { return this.name; };
-lang_Identifier.prototype.set$name = function(value) { return this.name = value; };
-lang_Identifier.prototype.visit = function(visitor) {
+$inherits(Identifier, Node);
+Identifier.prototype.get$name = function() { return this.name; };
+Identifier.prototype.set$name = function(value) { return this.name = value; };
+Identifier.prototype.visit = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for DeclaredIdentifier **************
 function DeclaredIdentifier(type, name, span) {
   this.type = type;
   this.name = name;
-  lang_Expression.call(this, span);
+  Expression.call(this, span);
   // Initializers done
 }
-$inherits(DeclaredIdentifier, lang_Expression);
+$inherits(DeclaredIdentifier, Expression);
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 // ********** Code for TreePrinter **************
 function TreePrinter() {}
 TreePrinter.prototype.visitDirectiveDefinition = function(node) {
   this.output.heading('DirectiveDefinition', node.span);
   this.output.writeNode('name', node.name);
@@ skipping 251 matching lines @@
 }
 TreePrinter.prototype.visitDeclaredIdentifier = function(node) {
   this.output.heading('DeclaredIdentifier', node.span);
   this.output.writeNode('type', node.type);
   this.output.writeNode('name', node.name);
 }
 TreePrinter.prototype.visitTypeReference = function(node) {
   this.output.heading('TypeReference(' + this.output.toValue(node.type) + ")", node.span);
 }
 $defineMethod(TreePrinter, "visitPostfixExpression$1", TreePrinter.prototype.visitPostfixExpression);
-// ********** Code for lang_Type **************
-function lang_Type(name) {
+// ********** Code for Type **************
+function Type(name) {
   this.name = name;
   this.isTested = false;
   // Initializers done
 }
-lang_Type.prototype.get$name = function() { return this.name; };
-lang_Type.prototype.markUsed = function() {
+Type.prototype.get$name = function() { return this.name; };
+Type.prototype.markUsed = function() {
 
 }
-lang_Type.prototype.get$typeMember = function() {
+Type.prototype.get$typeMember = function() {
   if (this._typeMember == null) {
     this._typeMember = new TypeMember(this);
   }
   return this._typeMember;
 }
-lang_Type.prototype.getMember = function(name) {
+Type.prototype.getMember = function(name) {
   return null;
 }
-lang_Type.prototype.get$isVar = function() {
+Type.prototype.get$isVar = function() {
   return false;
 }
-lang_Type.prototype.get$isTop = function() {
+Type.prototype.get$isTop = function() {
   return false;
 }
-lang_Type.prototype.get$isObject = function() {
+Type.prototype.get$isObject = function() {
   return false;
 }
-lang_Type.prototype.get$isString = function() {
+Type.prototype.get$isString = function() {
   return false;
 }
-lang_Type.prototype.get$isBool = function() {
+Type.prototype.get$isBool = function() {
   return false;
 }
-lang_Type.prototype.get$isFunction = function() {
+Type.prototype.get$isFunction = function() {
   return false;
 }
-lang_Type.prototype.get$isList = function() {
+Type.prototype.get$isList = function() {
   return false;
 }
-lang_Type.prototype.get$isNum = function() {
+Type.prototype.get$isNum = function() {
   return false;
 }
-lang_Type.prototype.get$isVarOrFunction = function() {
+Type.prototype.get$isVarOrFunction = function() {
   return this.get$isVar() || this.get$isFunction();
 }
-lang_Type.prototype.getCallMethod = function() {
+Type.prototype.getCallMethod = function() {
   return null;
 }
-lang_Type.prototype.get$isClosed = function() {
+Type.prototype.get$isClosed = function() {
   return this.get$isString() || this.get$isBool() || this.get$isNum() || this.get$isFunction();
 }
-lang_Type.prototype.get$isUsed = function() {
+Type.prototype.get$isUsed = function() {
   return false;
 }
-lang_Type.prototype.get$isGeneric = function() {
+Type.prototype.get$isGeneric = function() {
   return false;
 }
-lang_Type.prototype.get$isNativeType = function() {
+Type.prototype.get$isNativeType = function() {
   return false;
 }
-lang_Type.prototype.get$isNative = function() {
+Type.prototype.get$isNative = function() {
   return this.get$isNativeType();
 }
-lang_Type.prototype.get$hasTypeParams = function() {
+Type.prototype.get$hasTypeParams = function() {
   return false;
 }
-lang_Type.prototype.get$typeofName = function() {
+Type.prototype.get$typeofName = function() {
   return null;
 }
-lang_Type.prototype.get$jsname = function() {
+Type.prototype.get$jsname = function() {
   return this._jsname == null ? this.name : this._jsname;
 }
-lang_Type.prototype.set$jsname = function(name) {
+Type.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
-lang_Type.prototype.getAllMembers = function() {
+Type.prototype.getAllMembers = function() {
   return $map([]);
 }
-lang_Type.prototype.needsVarCall = function(args) {
+Type.prototype.needsVarCall = function(args) {
   if (this.get$isVarOrFunction()) {
     return true;
   }
   var call = this.getCallMethod();
   if ($ne(call, null)) {
     if (args.get$length() != call.get$parameters().length || !call.namesInOrder(args)) {
       return true;
     }
   }
   return false;
 }
-lang_Type.union = function(x, y) {
+Type.union = function(x, y) {
   if ($eq(x, y)) return x;
   if (x.get$isNum() && y.get$isNum()) return world.numType;
   if (x.get$isString() && y.get$isString()) return world.stringType;
   return world.varType;
 }
 // ********** Code for ParameterType **************
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
 }
-$inherits(ParameterType, lang_Type);
+$inherits(ParameterType, Type);
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.getCallMethod = function() {
@@ skipping 23 matching lines @@
   }
 }
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
 }
-$inherits(ConcreteType, lang_Type);
+$inherits(ConcreteType, Type);
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.get$isClass();
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.get$library();
 }
 ConcreteType.prototype.get$span = function() {
@@ skipping 133 matching lines @@
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = [];
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
-  lang_Type.call(this, name);
+  Type.call(this, name);
   // Initializers done
   this.setDefinition(definition);
 }
-$inherits(DefinedType, lang_Type);
+$inherits(DefinedType, Type);
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$parent = function() { return this.parent; };
 DefinedType.prototype.set$parent = function(value) { return this.parent = value; };
 DefinedType.prototype.get$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 DefinedType.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefinedType.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
@@ skipping 660 matching lines @@
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
   if ($eq(other, this)) {
     return 0;
   }
   else if (this.dependencies.indexOf(other, 0) >= 0) {
     return 1;
   }
   else if (other.dependencies.indexOf(this, 0) >= 0) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.dependencies.length > other.dependencies.length) {
     return 1;
   }
   else if (this.dependencies.length < other.dependencies.length) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.name == null && other.name != null) {
     return 1;
   }
   else if (this.name != null && other.name == null) {
-    return -1;
+    return -1.000000/*-1*/;
   }
   else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
@@ skipping 147 matching lines @@
       throw exc;
     }
   }
   this.printStatus();
   return !this.get$hasErrors();
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
   if (!options.enableLeg) return false;
   return this.withTiming('try leg compile', (function () {
-    return compile($this);
+    return leg_compile($this);
   })
   );
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
@@ skipping 477 matching lines @@
   }
   else {
     return text;
   }
 }
 var world;
 function initializeWorld(files) {
   world = new World(files);
   world.init();
 }
-function lang_compile(homedir, args, files) {
+function compile(homedir, args, files) {
   parseOptions(homedir, args);
   initializeWorld(files);
   var success = world.compile();
   if (options.outfile != null) {
     if (success) {
       var code = world.getGeneratedCode();
       if (!options.outfile.endsWith('.js')) {
         code = '#!/usr/bin/env node\n' + code;
       }
       world.files.writeString(options.outfile, code);
@@ skipping 13 matching lines @@
   for (var i = args.get$bareCount();
    i < args.get$length(); i++) {
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = get$path().dirname(get$fs().realpathSync(process.argv.$index(1)));
-  if (lang_compile(homedir, process.argv, new NodeFileSystem())) {
+  if (compile(homedir, process.argv, new NodeFileSystem())) {
     var code = world.getGeneratedCode();
     if (!options.compileOnly) {
       process.argv = [process.argv.$index(0), process.argv.$index(1)];
       process.argv.addAll(options.childArgs);
       runCodeWithContext(code);
     }
   }
   else {
     process.exit(1);
   }
 }
 $defineMethod(Function, "to$call$1", function() {
   this.call$1 = this.$genStub(1);
   this.to$call$1 = function() { return this.call$1; };
   return this.call$1;
 });
 $defineMethod(Function, "call$1", function(item) {
   return this.to$call$1()(item);
 });
 function to$call$1(f) { return f && f.to$call$1(); }
 $defineMethod(Function, "to$call$2", function() {
   this.call$2 = this.$genStub(2);
   this.to$call$2 = function() { return this.call$2; };
   return this.call$2;
 });
 $defineMethod(Function, "call$2", function(current, count) {
   return this.to$call$2()(current, count);
 });
 function to$call$2(f) { return f && f.to$call$2(); }
-var const$10 = new EmptyQueueException()/*const EmptyQueueException()*/;
+var const$120 = []/*const <HInstruction>[]*/;
+var const$121 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
+var const$122 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$129 = new StringWrapper('main')/*const SourceString('main')*/;
-var const$133 = new StringWrapper('void')/*const SourceString('void')*/;
-var const$135 = new StringWrapper('int')/*const SourceString('int')*/;
-var const$137 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
-var const$139 = new StringWrapper('print')/*const SourceString('print')*/;
-var const$140 = new StringWrapper('+')/*const SourceString('+')*/;
-var const$238 = new Keyword("break", false)/*const Keyword("break")*/;
-var const$240 = new Keyword("case", false)/*const Keyword("case")*/;
-var const$242 = new Keyword("catch", false)/*const Keyword("catch")*/;
-var const$244 = new Keyword("const", false)/*const Keyword("const")*/;
-var const$246 = new Keyword("continue", false)/*const Keyword("continue")*/;
-var const$248 = new Keyword("default", false)/*const Keyword("default")*/;
-var const$250 = new Keyword("do", false)/*const Keyword("do")*/;
-var const$252 = new Keyword("else", false)/*const Keyword("else")*/;
-var const$254 = new Keyword("false", false)/*const Keyword("false")*/;
-var const$256 = new Keyword("final", false)/*const Keyword("final")*/;
-var const$258 = new Keyword("finally", false)/*const Keyword("finally")*/;
-var const$260 = new Keyword("for", false)/*const Keyword("for")*/;
-var const$262 = new Keyword("if", false)/*const Keyword("if")*/;
-var const$264 = new Keyword("in", false)/*const Keyword("in")*/;
-var const$266 = new Keyword("is", false)/*const Keyword("is")*/;
-var const$268 = new Keyword("new", false)/*const Keyword("new")*/;
-var const$270 = new Keyword("null", false)/*const Keyword("null")*/;
-var const$272 = new Keyword("return", false)/*const Keyword("return")*/;
-var const$274 = new Keyword("super", false)/*const Keyword("super")*/;
-var const$276 = new Keyword("switch", false)/*const Keyword("switch")*/;
-var const$278 = new Keyword("this", false)/*const Keyword("this")*/;
-var const$280 = new Keyword("throw", false)/*const Keyword("throw")*/;
-var const$282 = new Keyword("true", false)/*const Keyword("true")*/;
-var const$284 = new Keyword("try", false)/*const Keyword("try")*/;
-var const$286 = new Keyword("var", false)/*const Keyword("var")*/;
-var const$288 = new Keyword("void", false)/*const Keyword("void")*/;
-var const$290 = new Keyword("while", false)/*const Keyword("while")*/;
-var const$292 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
-var const$294 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
-var const$296 = new Keyword("class", true)/*const Keyword("class", true)*/;
-var const$298 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
-var const$300 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
-var const$302 = new Keyword("get", true)/*const Keyword("get", true)*/;
-var const$304 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
-var const$306 = new Keyword("import", true)/*const Keyword("import", true)*/;
-var const$308 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
-var const$310 = new Keyword("library", true)/*const Keyword("library", true)*/;
-var const$312 = new Keyword("native", true)/*const Keyword("native", true)*/;
-var const$314 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
-var const$316 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
-var const$318 = new Keyword("set", true)/*const Keyword("set", true)*/;
-var const$320 = new Keyword("source", true)/*const Keyword("source", true)*/;
-var const$322 = new Keyword("static", true)/*const Keyword("static", true)*/;
-var const$324 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
-var const$328 = new LinkTail()/*const LinkTail()*/;
-var const$329 = new StringWrapper("<")/*const SourceString("<")*/;
-var const$330 = new StringWrapper(".")/*const SourceString(".")*/;
-var const$331 = new StringWrapper(",")/*const SourceString(",")*/;
-var const$332 = new StringWrapper(">")/*const SourceString(">")*/;
-var const$333 = new StringWrapper("{")/*const SourceString("{")*/;
-var const$334 = new StringWrapper("string")/*const SourceString("string")*/;
-var const$335 = new StringWrapper("(")/*const SourceString("(")*/;
-var const$336 = new StringWrapper(")")/*const SourceString(")")*/;
-var const$337 = new StringWrapper(";")/*const SourceString(";")*/;
-var const$338 = new StringWrapper("#")/*const SourceString("#")*/;
-var const$339 = new StringWrapper("=")/*const SourceString("=")*/;
-var const$340 = new StringWrapper("}")/*const SourceString("}")*/;
-var const$341 = new StringWrapper("return")/*const SourceString("return")*/;
-var const$8 = []/*const <HInstruction>[]*/;
-var const$9 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
+var const$228 = new Keyword("break", false)/*const Keyword("break")*/;
+var const$230 = new Keyword("case", false)/*const Keyword("case")*/;
+var const$232 = new Keyword("catch", false)/*const Keyword("catch")*/;
+var const$234 = new Keyword("const", false)/*const Keyword("const")*/;
+var const$236 = new Keyword("continue", false)/*const Keyword("continue")*/;
+var const$238 = new Keyword("default", false)/*const Keyword("default")*/;
+var const$240 = new Keyword("do", false)/*const Keyword("do")*/;
+var const$242 = new Keyword("else", false)/*const Keyword("else")*/;
+var const$244 = new Keyword("false", false)/*const Keyword("false")*/;
+var const$246 = new Keyword("final", false)/*const Keyword("final")*/;
+var const$248 = new Keyword("finally", false)/*const Keyword("finally")*/;
+var const$250 = new Keyword("for", false)/*const Keyword("for")*/;
+var const$252 = new Keyword("if", false)/*const Keyword("if")*/;
+var const$254 = new Keyword("in", false)/*const Keyword("in")*/;
+var const$256 = new Keyword("is", false)/*const Keyword("is")*/;
+var const$258 = new Keyword("new", false)/*const Keyword("new")*/;
+var const$260 = new Keyword("null", false)/*const Keyword("null")*/;
+var const$262 = new Keyword("return", false)/*const Keyword("return")*/;
+var const$264 = new Keyword("super", false)/*const Keyword("super")*/;
+var const$266 = new Keyword("switch", false)/*const Keyword("switch")*/;
+var const$268 = new Keyword("this", false)/*const Keyword("this")*/;
+var const$270 = new Keyword("throw", false)/*const Keyword("throw")*/;
+var const$272 = new Keyword("true", false)/*const Keyword("true")*/;
+var const$274 = new Keyword("try", false)/*const Keyword("try")*/;
+var const$276 = new Keyword("var", false)/*const Keyword("var")*/;
+var const$278 = new Keyword("void", false)/*const Keyword("void")*/;
+var const$280 = new Keyword("while", false)/*const Keyword("while")*/;
+var const$282 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
+var const$284 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
+var const$286 = new Keyword("class", true)/*const Keyword("class", true)*/;
+var const$288 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
+var const$290 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
+var const$292 = new Keyword("get", true)/*const Keyword("get", true)*/;
+var const$294 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
+var const$296 = new Keyword("import", true)/*const Keyword("import", true)*/;
+var const$298 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
+var const$300 = new Keyword("library", true)/*const Keyword("library", true)*/;
+var const$302 = new Keyword("native", true)/*const Keyword("native", true)*/;
+var const$304 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
+var const$306 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
+var const$308 = new Keyword("set", true)/*const Keyword("set", true)*/;
+var const$310 = new Keyword("source", true)/*const Keyword("source", true)*/;
+var const$312 = new Keyword("static", true)/*const Keyword("static", true)*/;
+var const$314 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
+var const$318 = new LinkTail()/*const LinkTail()*/;
+var const$319 = new StringWrapper("<")/*const SourceString("<")*/;
+var const$320 = new StringWrapper(".")/*const SourceString(".")*/;
+var const$321 = new StringWrapper(",")/*const SourceString(",")*/;
+var const$322 = new StringWrapper(">")/*const SourceString(">")*/;
+var const$323 = new StringWrapper("{")/*const SourceString("{")*/;
+var const$324 = new StringWrapper("string")/*const SourceString("string")*/;
+var const$325 = new StringWrapper("(")/*const SourceString("(")*/;
+var const$326 = new StringWrapper(")")/*const SourceString(")")*/;
+var const$327 = new StringWrapper(";")/*const SourceString(";")*/;
+var const$328 = new StringWrapper("#")/*const SourceString("#")*/;
+var const$329 = new StringWrapper("=")/*const SourceString("=")*/;
+var const$330 = new StringWrapper("}")/*const SourceString("}")*/;
+var const$331 = new StringWrapper("return")/*const SourceString("return")*/;
+var const$333 = new StringWrapper('print')/*const SourceString('print')*/;
+var const$334 = new StringWrapper('+')/*const SourceString('+')*/;
+var const$336 = new StringWrapper('void')/*const SourceString('void')*/;
+var const$338 = new StringWrapper('int')/*const SourceString('int')*/;
+var const$340 = new StringWrapper('Dynamic')/*const SourceString('Dynamic')*/;
 var $0 = 48;
 var $1 = 49;
 var $2 = 50;
 var $3 = 51;
 var $4 = 52;
 var $5 = 53;
 var $6 = 54;
 var $7 = 55;
 var $8 = 56;
 var $9 = 57;
@@ skipping 169 matching lines @@
 TokenKind.LBRACE = 6;
 TokenKind.LBRACK = 4;
 TokenKind.LIBRARY = 79;
 Math.LN10 = 2.302585092994046;
 Math.LN2 = 0.6931471805599453;
 Math.LOG10E = 0.4342944819032518;
 Math.LOG2E = 1.4426950408889634;
 TokenKind.LPAREN = 2;
 TokenKind.LT = 52;
 TokenKind.LTE = 54;
-Duration.MILLISECONDS_PER_DAY = 86400000/*MILLISECONDS_PER_HOUR * HOURS_PER_DAY*/;
-Duration.MILLISECONDS_PER_HOUR = 3600000/*MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR*/;
-Duration.MILLISECONDS_PER_MINUTE = 60000/*MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE*/;
+Duration.MILLISECONDS_PER_DAY = 86400000.000000/*MILLISECONDS_PER_HOUR * HOURS_PER_DAY*/;
+Duration.MILLISECONDS_PER_HOUR = 3600000.000000/*MILLISECONDS_PER_MINUTE * MINUTES_PER_HOUR*/;
+Duration.MILLISECONDS_PER_MINUTE = 60000.000000/*MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE*/;
 Duration.MILLISECONDS_PER_SECOND = 1000;
 Duration.MINUTES_PER_HOUR = 60;
 TokenKind.MOD = 47;
 TokenKind.MUL = 44;
 TokenKind.NATIVE = 80;
 TokenKind.NE = 49;
 TokenKind.NEGATE = 81;
 TokenKind.NEW = 102;
 CodeWriter.NEWLINE = '\n';
 TokenKind.NE_STRICT = 51;
@@ skipping 33 matching lines @@
 TokenKind.TRUE = 109;
 TokenKind.TRUNCDIV = 46;
 TokenKind.TRY = 110;
 TokenKind.TYPEDEF = 86;
 TokenKind.VAR = 111;
 TokenKind.VOID = 112;
 TokenKind.WHILE = 113;
 TokenKind.WHITESPACE = 62;
 HashMapImplementation._INITIAL_CAPACITY = 8;
 var _SPAWNED_SIGNAL = "spawned";
-var const$134 = new SimpleType(const$133)/*const SimpleType(const SourceString('void'))*/;
-var const$136 = new SimpleType(const$135)/*const SimpleType(const SourceString('int'))*/;
-var const$138 = new SimpleType(const$137)/*const SimpleType(const SourceString('Dynamic'))*/;
-Keyword.ABSTRACT = const$292/*const Keyword("abstract", true)*/;
-Keyword.ASSERT = const$294/*const Keyword("assert", true)*/;
-Keyword.BREAK = const$238/*const Keyword("break")*/;
-Keyword.CASE = const$240/*const Keyword("case")*/;
-Keyword.CATCH = const$242/*const Keyword("catch")*/;
-Keyword.CLASS = const$296/*const Keyword("class", true)*/;
-Keyword.CONST = const$244/*const Keyword("const")*/;
-Keyword.CONTINUE = const$246/*const Keyword("continue")*/;
-Keyword.DEFAULT = const$248/*const Keyword("default")*/;
-Keyword.DO = const$250/*const Keyword("do")*/;
-Keyword.ELSE = const$252/*const Keyword("else")*/;
-Keyword.EXTENDS = const$298/*const Keyword("extends", true)*/;
-Keyword.FACTORY = const$300/*const Keyword("factory", true)*/;
-Keyword.FALSE = const$254/*const Keyword("false")*/;
-Keyword.FINAL = const$256/*const Keyword("final")*/;
-Keyword.FINALLY = const$258/*const Keyword("finally")*/;
-Keyword.FOR = const$260/*const Keyword("for")*/;
-Keyword.GET = const$302/*const Keyword("get", true)*/;
-Keyword.IF = const$262/*const Keyword("if")*/;
-Keyword.IMPLEMENTS = const$304/*const Keyword("implements", true)*/;
-Keyword.IMPORT = const$306/*const Keyword("import", true)*/;
-Keyword.IN = const$264/*const Keyword("in")*/;
-Keyword.INTERFACE = const$308/*const Keyword("interface", true)*/;
-Keyword.IS = const$266/*const Keyword("is")*/;
-Keyword.LIBRARY = const$310/*const Keyword("library", true)*/;
-Keyword.NATIVE = const$312/*const Keyword("native", true)*/;
-Keyword.NEGATE = const$314/*const Keyword("negate", true)*/;
-Keyword.NEW = const$268/*const Keyword("new")*/;
-Keyword.NULL = const$270/*const Keyword("null")*/;
-Keyword.OPERATOR = const$316/*const Keyword("operator", true)*/;
-Keyword.RETURN = const$272/*const Keyword("return")*/;
-Keyword.SET = const$318/*const Keyword("set", true)*/;
-Keyword.SOURCE = const$320/*const Keyword("source", true)*/;
-Keyword.STATIC = const$322/*const Keyword("static", true)*/;
-Keyword.SUPER = const$274/*const Keyword("super")*/;
-Keyword.SWITCH = const$276/*const Keyword("switch")*/;
-Keyword.THIS = const$278/*const Keyword("this")*/;
-Keyword.THROW = const$280/*const Keyword("throw")*/;
-Keyword.TRUE = const$282/*const Keyword("true")*/;
-Keyword.TRY = const$284/*const Keyword("try")*/;
-Keyword.TYPEDEF = const$324/*const Keyword("typedef", true)*/;
-Keyword.VAR = const$286/*const Keyword("var")*/;
-Keyword.VOID = const$288/*const Keyword("void")*/;
-Keyword.WHILE = const$290/*const Keyword("while")*/;
-var const$326 = [const$238, const$240, const$242, const$244, const$246, const$248, const$250, const$252, const$254, const$256, const$258, const$260, const$262, const$264, const$266, const$268, const$270, const$272, const$274, const$276, const$278, const$280, const$282, const$284, const$286, const$288, const$290, const$292, const$294, const$296, const$298, const$300, const$302, const$304, const$306, const$308, const$310, const$312, const$314, const$316, const$318, const$320, const$322, const$324]/*const <Keyword> [
+var const$337 = new SimpleType(const$336)/*const SimpleType(const SourceString('void'))*/;
+var const$339 = new SimpleType(const$338)/*const SimpleType(const SourceString('int'))*/;
+var const$341 = new SimpleType(const$340)/*const SimpleType(const SourceString('Dynamic'))*/;
+Keyword.ABSTRACT = const$282/*const Keyword("abstract", true)*/;
+Keyword.ASSERT = const$284/*const Keyword("assert", true)*/;
+Keyword.BREAK = const$228/*const Keyword("break")*/;
+Keyword.CASE = const$230/*const Keyword("case")*/;
+Keyword.CATCH = const$232/*const Keyword("catch")*/;
+Keyword.CLASS = const$286/*const Keyword("class", true)*/;
+Keyword.CONST = const$234/*const Keyword("const")*/;
+Keyword.CONTINUE = const$236/*const Keyword("continue")*/;
+Keyword.DEFAULT = const$238/*const Keyword("default")*/;
+Keyword.DO = const$240/*const Keyword("do")*/;
+Keyword.ELSE = const$242/*const Keyword("else")*/;
+Keyword.EXTENDS = const$288/*const Keyword("extends", true)*/;
+Keyword.FACTORY = const$290/*const Keyword("factory", true)*/;
+Keyword.FALSE = const$244/*const Keyword("false")*/;
+Keyword.FINAL = const$246/*const Keyword("final")*/;
+Keyword.FINALLY = const$248/*const Keyword("finally")*/;
+Keyword.FOR = const$250/*const Keyword("for")*/;
+Keyword.GET = const$292/*const Keyword("get", true)*/;
+Keyword.IF = const$252/*const Keyword("if")*/;
+Keyword.IMPLEMENTS = const$294/*const Keyword("implements", true)*/;
+Keyword.IMPORT = const$296/*const Keyword("import", true)*/;
+Keyword.IN = const$254/*const Keyword("in")*/;
+Keyword.INTERFACE = const$298/*const Keyword("interface", true)*/;
+Keyword.IS = const$256/*const Keyword("is")*/;
+Keyword.LIBRARY = const$300/*const Keyword("library", true)*/;
+Keyword.NATIVE = const$302/*const Keyword("native", true)*/;
+Keyword.NEGATE = const$304/*const Keyword("negate", true)*/;
+Keyword.NEW = const$258/*const Keyword("new")*/;
+Keyword.NULL = const$260/*const Keyword("null")*/;
+Keyword.OPERATOR = const$306/*const Keyword("operator", true)*/;
+Keyword.RETURN = const$262/*const Keyword("return")*/;
+Keyword.SET = const$308/*const Keyword("set", true)*/;
+Keyword.SOURCE = const$310/*const Keyword("source", true)*/;
+Keyword.STATIC = const$312/*const Keyword("static", true)*/;
+Keyword.SUPER = const$264/*const Keyword("super")*/;
+Keyword.SWITCH = const$266/*const Keyword("switch")*/;
+Keyword.THIS = const$268/*const Keyword("this")*/;
+Keyword.THROW = const$270/*const Keyword("throw")*/;
+Keyword.TRUE = const$272/*const Keyword("true")*/;
+Keyword.TRY = const$274/*const Keyword("try")*/;
+Keyword.TYPEDEF = const$314/*const Keyword("typedef", true)*/;
+Keyword.VAR = const$276/*const Keyword("var")*/;
+Keyword.VOID = const$278/*const Keyword("void")*/;
+Keyword.WHILE = const$280/*const Keyword("while")*/;
+var const$316 = [const$228, const$230, const$232, const$234, const$236, const$238, const$240, const$242, const$244, const$246, const$248, const$250, const$252, const$254, const$256, const$258, const$260, const$262, const$264, const$266, const$268, const$270, const$272, const$274, const$276, const$278, const$280, const$282, const$284, const$286, const$288, const$290, const$292, const$294, const$296, const$298, const$300, const$302, const$304, const$306, const$308, const$310, const$312, const$314]/*const <Keyword> [
       BREAK,
       CASE,
       CATCH,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
       ELSE,
       FALSE,
       FINAL,
@@ skipping 24 matching lines @@
       IMPORT,
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
-Keyword.values = const$326/*const <Keyword> [
+Keyword.values = const$316/*const <Keyword> [
       BREAK,
       CASE,
       CATCH,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
       ELSE,
       FALSE,
       FINAL,
@@ skipping 25 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();